579 lines
21 KiB
C++
579 lines
21 KiB
C++
// escena_titol.cpp - Implementació de l'escena de títol
|
||
// © 2025 Port a C++20
|
||
|
||
#include "escena_titol.hpp"
|
||
|
||
#include <cfloat>
|
||
#include <cmath>
|
||
#include <iostream>
|
||
#include <string>
|
||
|
||
#include "core/audio/audio.hpp"
|
||
#include "core/graphics/shape_loader.hpp"
|
||
#include "core/input/mouse.hpp"
|
||
#include "core/rendering/shape_renderer.hpp"
|
||
#include "core/system/context_escenes.hpp"
|
||
#include "core/system/global_events.hpp"
|
||
#include "project.h"
|
||
|
||
// Using declarations per simplificar el codi
|
||
using GestorEscenes::ContextEscenes;
|
||
using Escena = ContextEscenes::Escena;
|
||
using Opcio = ContextEscenes::Opcio;
|
||
|
||
EscenaTitol::EscenaTitol(SDLManager& sdl, ContextEscenes& context)
|
||
: sdl_(sdl),
|
||
context_(context),
|
||
text_(sdl.obte_renderer()),
|
||
estat_actual_(EstatTitol::STARFIELD_FADE_IN),
|
||
temps_acumulat_(0.0f),
|
||
temps_animacio_(0.0f),
|
||
temps_estat_main_(0.0f),
|
||
animacio_activa_(false),
|
||
factor_lerp_(0.0f) {
|
||
std::cout << "Escena Titol: Inicialitzant...\n";
|
||
|
||
// Processar opció del context
|
||
auto opcio = context_.consumir_opcio();
|
||
|
||
if (opcio == Opcio::JUMP_TO_TITLE_MAIN) {
|
||
std::cout << "Escena Titol: Opció JUMP_TO_TITLE_MAIN activada\n";
|
||
estat_actual_ = EstatTitol::MAIN;
|
||
temps_estat_main_ = 0.0f;
|
||
}
|
||
|
||
// Crear starfield de fons
|
||
Punt centre_pantalla{
|
||
Defaults::Game::WIDTH / 2.0f,
|
||
Defaults::Game::HEIGHT / 2.0f};
|
||
|
||
SDL_FRect area_completa{
|
||
0,
|
||
0,
|
||
static_cast<float>(Defaults::Game::WIDTH),
|
||
static_cast<float>(Defaults::Game::HEIGHT)};
|
||
|
||
starfield_ = std::make_unique<Graphics::Starfield>(
|
||
sdl_.obte_renderer(),
|
||
centre_pantalla,
|
||
area_completa,
|
||
150 // densitat: 150 estrelles (50 per capa)
|
||
);
|
||
|
||
// Brightness depèn de l'opció
|
||
if (estat_actual_ == EstatTitol::MAIN) {
|
||
// Si saltem a MAIN, starfield instantàniament brillant
|
||
starfield_->set_brightness(BRIGHTNESS_STARFIELD);
|
||
} else {
|
||
// Flux normal: comença amb brightness 0.0 per fade-in
|
||
starfield_->set_brightness(0.0f);
|
||
}
|
||
|
||
// Inicialitzar lletres del títol "ORNI ATTACK!"
|
||
inicialitzar_titol();
|
||
|
||
// Iniciar música de títol si no està sonant
|
||
if (Audio::get()->getMusicState() != Audio::MusicState::PLAYING) {
|
||
Audio::get()->playMusic("title.ogg");
|
||
}
|
||
}
|
||
|
||
EscenaTitol::~EscenaTitol() {
|
||
// Aturar música de títol quan es destrueix l'escena
|
||
Audio::get()->stopMusic();
|
||
}
|
||
|
||
void EscenaTitol::inicialitzar_titol() {
|
||
using namespace Graphics;
|
||
|
||
// === LÍNIA 1: "ORNI" ===
|
||
std::vector<std::string> fitxers_orni = {
|
||
"title/letra_o.shp",
|
||
"title/letra_r.shp",
|
||
"title/letra_n.shp",
|
||
"title/letra_i.shp"};
|
||
|
||
// Pas 1: Carregar formes i calcular amplades per "ORNI"
|
||
float ancho_total_orni = 0.0f;
|
||
|
||
for (const auto& fitxer : fitxers_orni) {
|
||
auto forma = ShapeLoader::load(fitxer);
|
||
if (!forma || !forma->es_valida()) {
|
||
std::cerr << "[EscenaTitol] Error carregant " << fitxer << std::endl;
|
||
continue;
|
||
}
|
||
|
||
// Calcular bounding box de la forma (trobar ancho i altura)
|
||
float min_x = FLT_MAX;
|
||
float max_x = -FLT_MAX;
|
||
float min_y = FLT_MAX;
|
||
float max_y = -FLT_MAX;
|
||
|
||
for (const auto& prim : forma->get_primitives()) {
|
||
for (const auto& punt : prim.points) {
|
||
min_x = std::min(min_x, punt.x);
|
||
max_x = std::max(max_x, punt.x);
|
||
min_y = std::min(min_y, punt.y);
|
||
max_y = std::max(max_y, punt.y);
|
||
}
|
||
}
|
||
|
||
float ancho_sin_escalar = max_x - min_x;
|
||
float altura_sin_escalar = max_y - min_y;
|
||
|
||
// Escalar ancho, altura i offset amb ESCALA_TITULO
|
||
float ancho = ancho_sin_escalar * ESCALA_TITULO;
|
||
float altura = altura_sin_escalar * ESCALA_TITULO;
|
||
float offset_centre = (forma->get_centre().x - min_x) * ESCALA_TITULO;
|
||
|
||
lletres_orni_.push_back({forma, {0.0f, 0.0f}, ancho, altura, offset_centre});
|
||
|
||
ancho_total_orni += ancho;
|
||
}
|
||
|
||
// Afegir espaiat entre lletres
|
||
ancho_total_orni += ESPAI_ENTRE_LLETRES * (lletres_orni_.size() - 1);
|
||
|
||
// Calcular posició inicial (centrat horitzontal) per "ORNI"
|
||
float x_inicial_orni = (Defaults::Game::WIDTH - ancho_total_orni) / 2.0f;
|
||
float x_actual = x_inicial_orni;
|
||
|
||
for (auto& lletra : lletres_orni_) {
|
||
lletra.posicio.x = x_actual + lletra.offset_centre;
|
||
lletra.posicio.y = Y_ORNI;
|
||
x_actual += lletra.ancho + ESPAI_ENTRE_LLETRES;
|
||
}
|
||
|
||
std::cout << "[EscenaTitol] Línia 1 (ORNI): " << lletres_orni_.size()
|
||
<< " lletres, ancho total: " << ancho_total_orni << " px\n";
|
||
|
||
// === Calcular posició Y dinàmica per "ATTACK!" ===
|
||
// Totes les lletres ORNI tenen la mateixa altura, utilitzem la primera
|
||
float altura_orni = lletres_orni_.empty() ? 50.0f : lletres_orni_[0].altura;
|
||
y_attack_dinamica_ = Y_ORNI + altura_orni + SEPARACION_LINEAS;
|
||
|
||
std::cout << "[EscenaTitol] Altura ORNI: " << altura_orni
|
||
<< " px, Y_ATTACK dinàmica: " << y_attack_dinamica_ << " px\n";
|
||
|
||
// === LÍNIA 2: "ATTACK!" ===
|
||
std::vector<std::string> fitxers_attack = {
|
||
"title/letra_a.shp",
|
||
"title/letra_t.shp",
|
||
"title/letra_t.shp", // T repetida
|
||
"title/letra_a.shp", // A repetida
|
||
"title/letra_c.shp",
|
||
"title/letra_k.shp",
|
||
"title/letra_exclamacion.shp"};
|
||
|
||
// Pas 1: Carregar formes i calcular amplades per "ATTACK!"
|
||
float ancho_total_attack = 0.0f;
|
||
|
||
for (const auto& fitxer : fitxers_attack) {
|
||
auto forma = ShapeLoader::load(fitxer);
|
||
if (!forma || !forma->es_valida()) {
|
||
std::cerr << "[EscenaTitol] Error carregant " << fitxer << std::endl;
|
||
continue;
|
||
}
|
||
|
||
// Calcular bounding box de la forma (trobar ancho i altura)
|
||
float min_x = FLT_MAX;
|
||
float max_x = -FLT_MAX;
|
||
float min_y = FLT_MAX;
|
||
float max_y = -FLT_MAX;
|
||
|
||
for (const auto& prim : forma->get_primitives()) {
|
||
for (const auto& punt : prim.points) {
|
||
min_x = std::min(min_x, punt.x);
|
||
max_x = std::max(max_x, punt.x);
|
||
min_y = std::min(min_y, punt.y);
|
||
max_y = std::max(max_y, punt.y);
|
||
}
|
||
}
|
||
|
||
float ancho_sin_escalar = max_x - min_x;
|
||
float altura_sin_escalar = max_y - min_y;
|
||
|
||
// Escalar ancho, altura i offset amb ESCALA_TITULO
|
||
float ancho = ancho_sin_escalar * ESCALA_TITULO;
|
||
float altura = altura_sin_escalar * ESCALA_TITULO;
|
||
float offset_centre = (forma->get_centre().x - min_x) * ESCALA_TITULO;
|
||
|
||
lletres_attack_.push_back({forma, {0.0f, 0.0f}, ancho, altura, offset_centre});
|
||
|
||
ancho_total_attack += ancho;
|
||
}
|
||
|
||
// Afegir espaiat entre lletres
|
||
ancho_total_attack += ESPAI_ENTRE_LLETRES * (lletres_attack_.size() - 1);
|
||
|
||
// Calcular posició inicial (centrat horitzontal) per "ATTACK!"
|
||
float x_inicial_attack = (Defaults::Game::WIDTH - ancho_total_attack) / 2.0f;
|
||
x_actual = x_inicial_attack;
|
||
|
||
for (auto& lletra : lletres_attack_) {
|
||
lletra.posicio.x = x_actual + lletra.offset_centre;
|
||
lletra.posicio.y = y_attack_dinamica_; // Usar posició dinàmica
|
||
x_actual += lletra.ancho + ESPAI_ENTRE_LLETRES;
|
||
}
|
||
|
||
std::cout << "[EscenaTitol] Línia 2 (ATTACK!): " << lletres_attack_.size()
|
||
<< " lletres, ancho total: " << ancho_total_attack << " px\n";
|
||
|
||
// Guardar posicions originals per l'animació orbital
|
||
posicions_originals_orni_.clear();
|
||
for (const auto& lletra : lletres_orni_) {
|
||
posicions_originals_orni_.push_back(lletra.posicio);
|
||
}
|
||
|
||
posicions_originals_attack_.clear();
|
||
for (const auto& lletra : lletres_attack_) {
|
||
posicions_originals_attack_.push_back(lletra.posicio);
|
||
}
|
||
|
||
std::cout << "[EscenaTitol] Animació: Posicions originals guardades\n";
|
||
}
|
||
|
||
void EscenaTitol::executar() {
|
||
SDL_Event event;
|
||
Uint64 last_time = SDL_GetTicks();
|
||
|
||
while (GestorEscenes::actual == Escena::TITOL) {
|
||
// Calcular delta_time real
|
||
Uint64 current_time = SDL_GetTicks();
|
||
float delta_time = (current_time - last_time) / 1000.0f;
|
||
last_time = current_time;
|
||
|
||
// Limitar delta_time per evitar grans salts
|
||
if (delta_time > 0.05f) {
|
||
delta_time = 0.05f;
|
||
}
|
||
|
||
// Actualitzar comptador de FPS
|
||
sdl_.updateFPS(delta_time);
|
||
|
||
// Actualitzar visibilitat del cursor (auto-ocultar)
|
||
Mouse::updateCursorVisibility();
|
||
|
||
// Processar events SDL
|
||
while (SDL_PollEvent(&event)) {
|
||
// Manejo de finestra
|
||
if (sdl_.handleWindowEvent(event)) {
|
||
continue;
|
||
}
|
||
|
||
// Events globals (F1/F2/F3/F4/ESC/QUIT)
|
||
if (GlobalEvents::handle(event, sdl_, context_)) {
|
||
continue;
|
||
}
|
||
|
||
// Processar events de l'escena
|
||
processar_events(event);
|
||
}
|
||
|
||
// Actualitzar lògica
|
||
actualitzar(delta_time);
|
||
|
||
// Actualitzar sistema d'audio
|
||
Audio::update();
|
||
|
||
// Actualitzar colors oscil·lats
|
||
sdl_.updateColors(delta_time);
|
||
|
||
// Netejar pantalla
|
||
sdl_.neteja(0, 0, 0);
|
||
|
||
// Actualitzar context de renderitzat (factor d'escala global)
|
||
sdl_.updateRenderingContext();
|
||
|
||
// Dibuixar
|
||
dibuixar();
|
||
|
||
// Presentar renderer (swap buffers)
|
||
sdl_.presenta();
|
||
}
|
||
|
||
std::cout << "Escena Titol: Finalitzant...\n";
|
||
}
|
||
|
||
void EscenaTitol::actualitzar(float delta_time) {
|
||
// Actualitzar starfield (sempre actiu)
|
||
if (starfield_) {
|
||
starfield_->actualitzar(delta_time);
|
||
}
|
||
|
||
switch (estat_actual_) {
|
||
case EstatTitol::STARFIELD_FADE_IN: {
|
||
temps_acumulat_ += delta_time;
|
||
|
||
// Calcular progrés del fade (0.0 → 1.0)
|
||
float progress = std::min(1.0f, temps_acumulat_ / DURACIO_FADE_IN);
|
||
|
||
// Lerp brightness de 0.0 a BRIGHTNESS_STARFIELD
|
||
float brightness_actual = progress * BRIGHTNESS_STARFIELD;
|
||
starfield_->set_brightness(brightness_actual);
|
||
|
||
// Transició a STARFIELD quan el fade es completa
|
||
if (temps_acumulat_ >= DURACIO_FADE_IN) {
|
||
estat_actual_ = EstatTitol::STARFIELD;
|
||
temps_acumulat_ = 0.0f; // Reset timer per al següent estat
|
||
starfield_->set_brightness(BRIGHTNESS_STARFIELD); // Assegurar valor final
|
||
}
|
||
break;
|
||
}
|
||
|
||
case EstatTitol::STARFIELD:
|
||
temps_acumulat_ += delta_time;
|
||
if (temps_acumulat_ >= DURACIO_INIT) {
|
||
estat_actual_ = EstatTitol::MAIN;
|
||
temps_estat_main_ = 0.0f; // Reset timer al entrar a MAIN
|
||
animacio_activa_ = false; // Comença estàtic
|
||
factor_lerp_ = 0.0f; // Sense animació encara
|
||
}
|
||
break;
|
||
|
||
case EstatTitol::MAIN: {
|
||
temps_estat_main_ += delta_time;
|
||
|
||
// Fase 1: Estàtic (0-10s)
|
||
if (temps_estat_main_ < DELAY_INICI_ANIMACIO) {
|
||
factor_lerp_ = 0.0f;
|
||
animacio_activa_ = false;
|
||
}
|
||
// Fase 2: Lerp (10-12s)
|
||
else if (temps_estat_main_ < DELAY_INICI_ANIMACIO + DURACIO_LERP) {
|
||
float temps_lerp = temps_estat_main_ - DELAY_INICI_ANIMACIO;
|
||
factor_lerp_ = temps_lerp / DURACIO_LERP; // 0.0 → 1.0 linealment
|
||
animacio_activa_ = true;
|
||
}
|
||
// Fase 3: Animació completa (12s+)
|
||
else {
|
||
factor_lerp_ = 1.0f;
|
||
animacio_activa_ = true;
|
||
}
|
||
|
||
// Actualitzar animació del logo
|
||
actualitzar_animacio_logo(delta_time);
|
||
break;
|
||
}
|
||
|
||
case EstatTitol::TRANSITION_TO_GAME:
|
||
temps_acumulat_ += delta_time;
|
||
|
||
// Continuar animació orbital durant la transició
|
||
actualitzar_animacio_logo(delta_time);
|
||
|
||
if (temps_acumulat_ >= DURACIO_TRANSITION) {
|
||
// Transició a JOC (la música ja s'ha parat en el fade)
|
||
GestorEscenes::actual = Escena::JOC;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
|
||
void EscenaTitol::actualitzar_animacio_logo(float delta_time) {
|
||
// Només calcular i aplicar offsets si l'animació està activa
|
||
if (animacio_activa_) {
|
||
// Acumular temps escalat
|
||
temps_animacio_ += delta_time * factor_lerp_;
|
||
|
||
// Usar amplituds i freqüències completes
|
||
float amplitude_x_actual = ORBIT_AMPLITUDE_X;
|
||
float amplitude_y_actual = ORBIT_AMPLITUDE_Y;
|
||
float frequency_x_actual = ORBIT_FREQUENCY_X;
|
||
float frequency_y_actual = ORBIT_FREQUENCY_Y;
|
||
|
||
// Calcular offset orbital
|
||
float offset_x = amplitude_x_actual * std::sin(2.0f * Defaults::Math::PI * frequency_x_actual * temps_animacio_);
|
||
float offset_y = amplitude_y_actual * std::sin(2.0f * Defaults::Math::PI * frequency_y_actual * temps_animacio_ + ORBIT_PHASE_OFFSET);
|
||
|
||
// Aplicar offset a totes les lletres de "ORNI"
|
||
for (size_t i = 0; i < lletres_orni_.size(); ++i) {
|
||
lletres_orni_[i].posicio.x = posicions_originals_orni_[i].x + static_cast<int>(std::round(offset_x));
|
||
lletres_orni_[i].posicio.y = posicions_originals_orni_[i].y + static_cast<int>(std::round(offset_y));
|
||
}
|
||
|
||
// Aplicar offset a totes les lletres de "ATTACK!"
|
||
for (size_t i = 0; i < lletres_attack_.size(); ++i) {
|
||
lletres_attack_[i].posicio.x = posicions_originals_attack_[i].x + static_cast<int>(std::round(offset_x));
|
||
lletres_attack_[i].posicio.y = posicions_originals_attack_[i].y + static_cast<int>(std::round(offset_y));
|
||
}
|
||
}
|
||
}
|
||
|
||
void EscenaTitol::dibuixar() {
|
||
// Dibuixar starfield de fons (sempre, en tots els estats)
|
||
if (starfield_) {
|
||
starfield_->dibuixar();
|
||
}
|
||
|
||
// En els estats STARFIELD_FADE_IN i STARFIELD, només mostrar starfield (sense text)
|
||
if (estat_actual_ == EstatTitol::STARFIELD_FADE_IN || estat_actual_ == EstatTitol::STARFIELD) {
|
||
return;
|
||
}
|
||
|
||
// Estat MAIN i TRANSITION: Dibuixar títol i text (sobre el starfield)
|
||
if (estat_actual_ == EstatTitol::MAIN || estat_actual_ == EstatTitol::TRANSITION_TO_GAME) {
|
||
// === Calcular i renderitzar ombra (només si animació activa) ===
|
||
if (animacio_activa_) {
|
||
float temps_shadow = temps_animacio_ - SHADOW_DELAY;
|
||
if (temps_shadow < 0.0f) temps_shadow = 0.0f; // Evitar temps negatiu
|
||
|
||
// Usar amplituds i freqüències completes per l'ombra
|
||
float amplitude_x_shadow = ORBIT_AMPLITUDE_X;
|
||
float amplitude_y_shadow = ORBIT_AMPLITUDE_Y;
|
||
float frequency_x_shadow = ORBIT_FREQUENCY_X;
|
||
float frequency_y_shadow = ORBIT_FREQUENCY_Y;
|
||
|
||
// Calcular offset de l'ombra
|
||
float shadow_offset_x = amplitude_x_shadow * std::sin(2.0f * Defaults::Math::PI * frequency_x_shadow * temps_shadow) + SHADOW_OFFSET_X;
|
||
float shadow_offset_y = amplitude_y_shadow * std::sin(2.0f * Defaults::Math::PI * frequency_y_shadow * temps_shadow + ORBIT_PHASE_OFFSET) + SHADOW_OFFSET_Y;
|
||
|
||
// === RENDERITZAR OMBRA PRIMER (darrera del logo principal) ===
|
||
|
||
// Ombra "ORNI"
|
||
for (size_t i = 0; i < lletres_orni_.size(); ++i) {
|
||
Punt pos_shadow;
|
||
pos_shadow.x = posicions_originals_orni_[i].x + static_cast<int>(std::round(shadow_offset_x));
|
||
pos_shadow.y = posicions_originals_orni_[i].y + static_cast<int>(std::round(shadow_offset_y));
|
||
|
||
Rendering::render_shape(
|
||
sdl_.obte_renderer(),
|
||
lletres_orni_[i].forma,
|
||
pos_shadow,
|
||
0.0f,
|
||
ESCALA_TITULO,
|
||
true,
|
||
1.0f, // progress = 1.0 (totalment visible)
|
||
SHADOW_BRIGHTNESS // brightness = 0.4 (brillantor reduïda)
|
||
);
|
||
}
|
||
|
||
// Ombra "ATTACK!"
|
||
for (size_t i = 0; i < lletres_attack_.size(); ++i) {
|
||
Punt pos_shadow;
|
||
pos_shadow.x = posicions_originals_attack_[i].x + static_cast<int>(std::round(shadow_offset_x));
|
||
pos_shadow.y = posicions_originals_attack_[i].y + static_cast<int>(std::round(shadow_offset_y));
|
||
|
||
Rendering::render_shape(
|
||
sdl_.obte_renderer(),
|
||
lletres_attack_[i].forma,
|
||
pos_shadow,
|
||
0.0f,
|
||
ESCALA_TITULO,
|
||
true,
|
||
1.0f, // progress = 1.0 (totalment visible)
|
||
SHADOW_BRIGHTNESS);
|
||
}
|
||
}
|
||
|
||
// === RENDERITZAR LOGO PRINCIPAL (damunt) ===
|
||
|
||
// Dibuixar "ORNI" (línia 1)
|
||
for (const auto& lletra : lletres_orni_) {
|
||
Rendering::render_shape(
|
||
sdl_.obte_renderer(),
|
||
lletra.forma,
|
||
lletra.posicio,
|
||
0.0f,
|
||
ESCALA_TITULO,
|
||
true,
|
||
1.0f // Brillantor completa
|
||
);
|
||
}
|
||
|
||
// Dibuixar "ATTACK!" (línia 2)
|
||
for (const auto& lletra : lletres_attack_) {
|
||
Rendering::render_shape(
|
||
sdl_.obte_renderer(),
|
||
lletra.forma,
|
||
lletra.posicio,
|
||
0.0f,
|
||
ESCALA_TITULO,
|
||
true,
|
||
1.0f // Brillantor completa
|
||
);
|
||
}
|
||
|
||
// === Text "PRESS BUTTON TO PLAY" ===
|
||
// En estat MAIN: sempre visible
|
||
// En estat TRANSITION: parpellejant (blink amb sinusoide)
|
||
|
||
const float spacing = 2.0f; // Espai entre caràcters (usat també per copyright)
|
||
|
||
bool mostrar_text = true;
|
||
if (estat_actual_ == EstatTitol::TRANSITION_TO_GAME) {
|
||
// Parpelleig: sin oscil·la entre -1 i 1, volem ON quan > 0
|
||
float fase = temps_acumulat_ * BLINK_FREQUENCY * 2.0f * 3.14159f; // 2π × freq × temps
|
||
mostrar_text = (std::sin(fase) > 0.0f);
|
||
}
|
||
|
||
if (mostrar_text) {
|
||
const std::string main_text = "PRESS BUTTON TO PLAY";
|
||
const float escala_main = 1.0f;
|
||
|
||
float text_width = text_.get_text_width(main_text, escala_main, spacing);
|
||
|
||
float x_center = (Defaults::Game::WIDTH - text_width) / 2.0f;
|
||
float altura_attack = lletres_attack_.empty() ? 50.0f : lletres_attack_[0].altura;
|
||
float y_center = y_attack_dinamica_ + altura_attack + 70.0f;
|
||
|
||
text_.render(main_text, Punt{x_center, y_center}, escala_main, spacing);
|
||
}
|
||
|
||
// === Copyright a la part inferior (centrat horitzontalment) ===
|
||
// Convert to uppercase since VectorText only supports A-Z
|
||
std::string copyright = Project::COPYRIGHT;
|
||
for (char& c : copyright) {
|
||
if (c >= 'a' && c <= 'z') {
|
||
c = c - 32; // Convert to uppercase
|
||
}
|
||
}
|
||
const float escala_copy = 0.6f;
|
||
|
||
float copy_width = text_.get_text_width(copyright, escala_copy, spacing);
|
||
float copy_height = text_.get_text_height(escala_copy);
|
||
|
||
float x_copy = (Defaults::Game::WIDTH - copy_width) / 2.0f;
|
||
float y_copy = Defaults::Game::HEIGHT - copy_height - 20.0f; // 20px des del fons
|
||
|
||
text_.render(copyright, Punt{x_copy, y_copy}, escala_copy, spacing);
|
||
}
|
||
}
|
||
|
||
void EscenaTitol::processar_events(const SDL_Event& event) {
|
||
// Qualsevol tecla o clic de ratolí
|
||
if (event.type == SDL_EVENT_KEY_DOWN ||
|
||
event.type == SDL_EVENT_MOUSE_BUTTON_DOWN) {
|
||
switch (estat_actual_) {
|
||
case EstatTitol::STARFIELD_FADE_IN:
|
||
// Saltar directament a MAIN (ometre fade-in i starfield)
|
||
estat_actual_ = EstatTitol::MAIN;
|
||
starfield_->set_brightness(BRIGHTNESS_STARFIELD); // Assegurar brightness final
|
||
temps_estat_main_ = 0.0f; // Reset timer per animació de títol
|
||
break;
|
||
|
||
case EstatTitol::STARFIELD:
|
||
// Saltar a MAIN
|
||
estat_actual_ = EstatTitol::MAIN;
|
||
temps_estat_main_ = 0.0f; // Reset timer
|
||
break;
|
||
|
||
case EstatTitol::MAIN:
|
||
// Utilitzar context per transició a JOC
|
||
context_.canviar_escena(Escena::JOC);
|
||
// NO actualitzar GestorEscenes::actual aquí!
|
||
// La transició es fa en l'estat TRANSITION_TO_GAME
|
||
|
||
// Iniciar transició amb fade-out de música
|
||
estat_actual_ = EstatTitol::TRANSITION_TO_GAME;
|
||
temps_acumulat_ = 0.0f; // Reset del comptador
|
||
Audio::get()->fadeOutMusic(MUSIC_FADE); // Fade de 300ms
|
||
break;
|
||
|
||
case EstatTitol::TRANSITION_TO_GAME:
|
||
// Ignorar inputs durant la transició
|
||
break;
|
||
}
|
||
}
|
||
}
|