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

LOGO explota

Browse Source
This commit is contained in:
Sergio
2025-12-02 08:50:38 +01:00
parent 73f222fcb7
commit 20538af4c6
22 changed files with 1754 additions and 1598 deletions
Download Patch File Download Diff File Expand all files Collapse all files

345
source/game/escenes/escena_joc.cpp
View File

@@ -3,233 +3,238 @@
// © 2025 Port a C++20 amb SDL3
#include "escena_joc.hpp"
#include "../../core/rendering/line_renderer.hpp"
#include "../../core/system/gestor_escenes.hpp"
#include "../../core/system/global_events.hpp"
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <iostream>
#include <vector>
EscenaJoc::EscenaJoc(SDLManager &sdl)
: sdl_(sdl), debris_manager_(sdl.obte_renderer()),
nau_(sdl.obte_renderer()), itocado_(0), text_(sdl.obte_renderer()) {
// Inicialitzar bales amb renderer
for (auto &bala : bales_) {
bala = Bala(sdl.obte_renderer());
}
#include "../../core/rendering/line_renderer.hpp"
#include "../../core/system/gestor_escenes.hpp"
#include "../../core/system/global_events.hpp"
// Inicialitzar enemics amb renderer
for (auto &enemy : orni_) {
enemy = Enemic(sdl.obte_renderer());
}
EscenaJoc::EscenaJoc(SDLManager& sdl)
: sdl_(sdl),
debris_manager_(sdl.obte_renderer()),
nau_(sdl.obte_renderer()),
itocado_(0),
text_(sdl.obte_renderer()) {
// Inicialitzar bales amb renderer
for (auto& bala : bales_) {
bala = Bala(sdl.obte_renderer());
}
// Inicialitzar enemics amb renderer
for (auto& enemy : orni_) {
enemy = Enemic(sdl.obte_renderer());
}
}
void EscenaJoc::executar() {
std::cout << "Escena Joc: Inicialitzant...\n";
std::cout << "Escena Joc: Inicialitzant...\n";
// Inicialitzar estat del joc
inicialitzar();
// Inicialitzar estat del joc
inicialitzar();
SDL_Event event;
Uint64 last_time = SDL_GetTicks();
SDL_Event event;
Uint64 last_time = SDL_GetTicks();
while (GestorEscenes::actual == GestorEscenes::Escena::JOC) {
// Calcular delta_time real
Uint64 current_time = SDL_GetTicks();
float delta_time = (current_time - last_time) / 1000.0f;
last_time = current_time;
while (GestorEscenes::actual == GestorEscenes::Escena::JOC) {
// 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;
// Limitar delta_time per evitar grans salts
if (delta_time > 0.05f) {
delta_time = 0.05f;
}
// Processar events SDL
while (SDL_PollEvent(&event)) {
// Manejo de finestra
if (sdl_.handleWindowEvent(event)) {
continue;
}
// Events globals (F1/F2/F3/ESC/QUIT)
if (GlobalEvents::handle(event, sdl_)) {
continue;
}
// Processament específic del joc (SPACE per disparar)
processar_input(event);
}
// Actualitzar física del joc amb delta_time real
actualitzar(delta_time);
// Actualitzar colors oscil·lats
sdl_.updateColors(delta_time);
// Netejar pantalla (usa color oscil·lat)
sdl_.neteja(0, 0, 0);
// Dibuixar joc
dibuixar();
// Presentar renderer (swap buffers)
sdl_.presenta();
}
// Processar events SDL
while (SDL_PollEvent(&event)) {
// Manejo de finestra
if (sdl_.handleWindowEvent(event)) {
continue;
}
// Events globals (F1/F2/F3/ESC/QUIT)
if (GlobalEvents::handle(event, sdl_)) {
continue;
}
// Processament específic del joc (SPACE per disparar)
processar_input(event);
}
// Actualitzar física del joc amb delta_time real
actualitzar(delta_time);
// Actualitzar colors oscil·lats
sdl_.updateColors(delta_time);
// Netejar pantalla (usa color oscil·lat)
sdl_.neteja(0, 0, 0);
// Dibuixar joc
dibuixar();
// Presentar renderer (swap buffers)
sdl_.presenta();
}
std::cout << "Escena Joc: Finalitzant...\n";
std::cout << "Escena Joc: Finalitzant...\n";
}
void EscenaJoc::inicialitzar() {
// Inicialitzar generador de números aleatoris
// Basat en el codi Pascal original: line 376
std::srand(static_cast<unsigned>(std::time(nullptr)));
// Inicialitzar generador de números aleatoris
// Basat en el codi Pascal original: line 376
std::srand(static_cast<unsigned>(std::time(nullptr)));
// Inicialitzar estat de col·lisió
itocado_ = 0;
// Inicialitzar estat de col·lisió
itocado_ = 0;
// Inicialitzar nau
nau_.inicialitzar();
// Inicialitzar nau
nau_.inicialitzar();
// Inicialitzar enemics (ORNIs)
for (auto &enemy : orni_) {
enemy.inicialitzar();
}
// Inicialitzar enemics (ORNIs)
for (auto& enemy : orni_) {
enemy.inicialitzar();
}
// Inicialitzar bales
for (auto &bala : bales_) {
bala.inicialitzar();
}
// Inicialitzar bales
for (auto& bala : bales_) {
bala.inicialitzar();
}
}
void EscenaJoc::actualitzar(float delta_time) {
// Actualitzar nau (input + física)
nau_.processar_input(delta_time);
nau_.actualitzar(delta_time);
// Actualitzar nau (input + física)
nau_.processar_input(delta_time);
nau_.actualitzar(delta_time);
// Actualitzar moviment i rotació dels enemics (ORNIs)
for (auto &enemy : orni_) {
enemy.actualitzar(delta_time);
}
// Actualitzar moviment i rotació dels enemics (ORNIs)
for (auto& enemy : orni_) {
enemy.actualitzar(delta_time);
}
// Actualitzar moviment de bales (Fase 9)
for (auto &bala : bales_) {
bala.actualitzar(delta_time);
}
// Actualitzar moviment de bales (Fase 9)
for (auto& bala : bales_) {
bala.actualitzar(delta_time);
}
// Actualitzar fragments d'explosions
debris_manager_.actualitzar(delta_time);
// Actualitzar fragments d'explosions
debris_manager_.actualitzar(delta_time);
}
void EscenaJoc::dibuixar() {
// Dibuixar marges de la zona de joc
dibuixar_marges();
// Dibuixar marges de la zona de joc
dibuixar_marges();
// Dibuixar nau
nau_.dibuixar();
// Dibuixar nau
nau_.dibuixar();
// Dibuixar ORNIs (enemics)
for (const auto &enemy : orni_) {
enemy.dibuixar();
}
// Dibuixar ORNIs (enemics)
for (const auto& enemy : orni_) {
enemy.dibuixar();
}
// Dibuixar bales (Fase 9)
for (const auto &bala : bales_) {
bala.dibuixar();
}
// Dibuixar bales (Fase 9)
for (const auto& bala : bales_) {
bala.dibuixar();
}
// Dibuixar fragments d'explosions (després d'altres objectes)
debris_manager_.dibuixar();
// Dibuixar fragments d'explosions (després d'altres objectes)
debris_manager_.dibuixar();
// Dibuixar marcador
dibuixar_marcador();
// Dibuixar marcador
dibuixar_marcador();
}
void EscenaJoc::processar_input(const SDL_Event &event) {
// Processament d'input per events puntuals (no continus)
// L'input continu (fletxes) es processa en actualitzar() amb
// SDL_GetKeyboardState()
void EscenaJoc::processar_input(const SDL_Event& event) {
// Processament d'input per events puntuals (no continus)
// L'input continu (fletxes) es processa en actualitzar() amb
// SDL_GetKeyboardState()
if (event.type == SDL_EVENT_KEY_DOWN) {
switch (event.key.key) {
case SDLK_SPACE: {
// TEMPORAL: Explotar enemic aleatori (per testing)
// TODO: Restaurar dispars quan el sistema d'explosions estiga validat
if (event.type == SDL_EVENT_KEY_DOWN) {
switch (event.key.key) {
case SDLK_SPACE: {
// TEMPORAL: Explotar enemic aleatori (per testing)
// TODO: Restaurar dispars quan el sistema d'explosions estiga validat
// Buscar tots els enemics actius
std::vector<int> enemics_actius;
for (int i = 0; i < Constants::MAX_ORNIS; i++) {
if (orni_[i].esta_actiu()) {
enemics_actius.push_back(i);
// Buscar tots els enemics actius
std::vector<int> enemics_actius;
for (int i = 0; i < Constants::MAX_ORNIS; i++) {
if (orni_[i].esta_actiu()) {
enemics_actius.push_back(i);
}
}
if (!enemics_actius.empty()) {
// Seleccionar enemic aleatori
int idx = enemics_actius[std::rand() % enemics_actius.size()];
// Crear explosió
debris_manager_.explotar(orni_[idx].get_forma(),
orni_[idx].get_centre(),
0.0f, // angle (enemics no roten físicament)
1.0f, // escala
Defaults::Physics::Debris::VELOCITAT_BASE);
// Desactivar enemic
orni_[idx].destruir();
std::cout << "[TEST] Enemic " << idx << " explotat!\n";
}
break;
}
default:
break;
}
}
if (!enemics_actius.empty()) {
// Seleccionar enemic aleatori
int idx = enemics_actius[std::rand() % enemics_actius.size()];
// Crear explosió
debris_manager_.explotar(orni_[idx].get_forma(),
orni_[idx].get_centre(),
0.0f, // angle (enemics no roten físicament)
1.0f, // escala
Defaults::Physics::Debris::VELOCITAT_BASE);
// Desactivar enemic
orni_[idx].destruir();
std::cout << "[TEST] Enemic " << idx << " explotat!\n";
}
break;
}
default:
break;
}
}
}
void EscenaJoc::tocado() {
// TODO: Implementar seqüència de mort
// TODO: Implementar seqüència de mort
}
void EscenaJoc::dibuixar_marges() const {
// Dibuixar rectangle de la zona de joc
const SDL_FRect &zona = Defaults::Zones::PLAYAREA;
// Dibuixar rectangle de la zona de joc
const SDL_FRect& zona = Defaults::Zones::PLAYAREA;
// Coordenades dels cantons
int x1 = static_cast<int>(zona.x);
int y1 = static_cast<int>(zona.y);
int x2 = static_cast<int>(zona.x + zona.w);
int y2 = static_cast<int>(zona.y + zona.h);
// Coordenades dels cantons
int x1 = static_cast<int>(zona.x);
int y1 = static_cast<int>(zona.y);
int x2 = static_cast<int>(zona.x + zona.w);
int y2 = static_cast<int>(zona.y + zona.h);
// 4 línies per formar el rectangle
Rendering::linea(sdl_.obte_renderer(), x1, y1, x2, y1, true); // Top
Rendering::linea(sdl_.obte_renderer(), x1, y2, x2, y2, true); // Bottom
Rendering::linea(sdl_.obte_renderer(), x1, y1, x1, y2, true); // Left
Rendering::linea(sdl_.obte_renderer(), x2, y1, x2, y2, true); // Right
// 4 línies per formar el rectangle
Rendering::linea(sdl_.obte_renderer(), x1, y1, x2, y1, true); // Top
Rendering::linea(sdl_.obte_renderer(), x1, y2, x2, y2, true); // Bottom
Rendering::linea(sdl_.obte_renderer(), x1, y1, x1, y2, true); // Left
Rendering::linea(sdl_.obte_renderer(), x2, y1, x2, y2, true); // Right
}
void EscenaJoc::dibuixar_marcador() {
// Text estàtic (hardcoded)
const std::string text = "SCORE: 01000 LIFE: 3 LEVEL: 01";
// Text estàtic (hardcoded)
const std::string text = "SCORE: 01000 LIFE: 3 LEVEL: 01";
// Paràmetres de renderització
const float escala = 0.85f;
const float spacing = 0.0f;
// Paràmetres de renderització
const float escala = 0.85f;
const float spacing = 0.0f;
// Calcular dimensions del text
float text_width = text_.get_text_width(text, escala, spacing);
float text_height = text_.get_text_height(escala);
// Calcular dimensions del text
float text_width = text_.get_text_width(text, escala, spacing);
float text_height = text_.get_text_height(escala);
// Centrat horitzontal dins de la zona del marcador
float x = (Defaults::Zones::SCOREBOARD.w - text_width) / 2.0f;
// Centrat horitzontal dins de la zona del marcador
float x = (Defaults::Zones::SCOREBOARD.w - text_width) / 2.0f;
// Centrat vertical dins de la zona del marcador
float y = Defaults::Zones::SCOREBOARD.y +
(Defaults::Zones::SCOREBOARD.h - text_height) / 2.0f;
// Centrat vertical dins de la zona del marcador
float y = Defaults::Zones::SCOREBOARD.y +
(Defaults::Zones::SCOREBOARD.h - text_height) / 2.0f;
// Renderitzar
text_.render(text, {x, y}, escala, spacing);
// Renderitzar
text_.render(text, {x, y}, escala, spacing);
}

68
source/game/escenes/escena_joc.hpp
View File

@@ -5,50 +5,52 @@
#ifndef ESCENA_JOC_HPP
#define ESCENA_JOC_HPP
#include "../../core/graphics/vector_text.hpp"
#include "../../core/rendering/sdl_manager.hpp"
#include "../effects/debris_manager.hpp"
#include "../../core/types.hpp"
#include "../constants.hpp"
#include "../entities/bala.hpp"
#include "../entities/enemic.hpp"
#include "../entities/nau.hpp"
#include <SDL3/SDL.h>
#include <array>
#include <cstdint>
#include "../../core/graphics/vector_text.hpp"
#include "../../core/rendering/sdl_manager.hpp"
#include "../../core/types.hpp"
#include "../constants.hpp"
#include "../effects/debris_manager.hpp"
#include "../entities/bala.hpp"
#include "../entities/enemic.hpp"
#include "../entities/nau.hpp"
// Classe principal del joc (escena)
class EscenaJoc {
public:
explicit EscenaJoc(SDLManager &sdl);
~EscenaJoc() = default;
public:
explicit EscenaJoc(SDLManager& sdl);
~EscenaJoc() = default;
void executar(); // Bucle principal de l'escena
void inicialitzar();
void actualitzar(float delta_time);
void dibuixar();
void processar_input(const SDL_Event &event);
void executar(); // Bucle principal de l'escena
void inicialitzar();
void actualitzar(float delta_time);
void dibuixar();
void processar_input(const SDL_Event& event);
private:
SDLManager &sdl_;
private:
SDLManager& sdl_;
// Efectes visuals
Effects::DebrisManager debris_manager_;
// Efectes visuals
Effects::DebrisManager debris_manager_;
// Estat del joc
Nau nau_;
std::array<Enemic, Constants::MAX_ORNIS> orni_;
std::array<Bala, Constants::MAX_BALES> bales_;
Poligon chatarra_cosmica_;
uint16_t itocado_;
// Estat del joc
Nau nau_;
std::array<Enemic, Constants::MAX_ORNIS> orni_;
std::array<Bala, Constants::MAX_BALES> bales_;
Poligon chatarra_cosmica_;
uint16_t itocado_;
// Text vectorial
Graphics::VectorText text_;
// Text vectorial
Graphics::VectorText text_;
// Funcions privades
void tocado();
void dibuixar_marges() const; // Dibuixar vores de la zona de joc
void dibuixar_marcador(); // Dibuixar marcador de puntuació
// Funcions privades
void tocado();
void dibuixar_marges() const; // Dibuixar vores de la zona de joc
void dibuixar_marcador(); // Dibuixar marcador de puntuació
};
#endif // ESCENA_JOC_HPP
#endif // ESCENA_JOC_HPP

488
source/game/escenes/escena_logo.cpp
View File

@@ -2,262 +2,340 @@
// © 2025 Port a C++20
#include "escena_logo.hpp"
#include "../../core/graphics/shape_loader.hpp"
#include "../../core/rendering/shape_renderer.hpp"
#include "../../core/system/gestor_escenes.hpp"
#include "../../core/system/global_events.hpp"
#include <algorithm>
#include <cfloat>
#include <iostream>
#include "../../core/graphics/shape_loader.hpp"
#include "../../core/rendering/shape_renderer.hpp"
#include "../../core/system/gestor_escenes.hpp"
#include "../../core/system/global_events.hpp"
// Helper: calcular el progrés individual d'una lletra
// en funció del progrés global (efecte seqüencial)
static float calcular_progress_letra(size_t letra_index, size_t num_letras,
float global_progress, float threshold) {
if (num_letras == 0)
return 1.0f;
static float calcular_progress_letra(size_t letra_index, size_t num_letras, float global_progress, float threshold) {
if (num_letras == 0)
return 1.0f;
// Calcular temps per lletra
float duration_per_letra = 1.0f / static_cast<float>(num_letras);
float step = threshold * duration_per_letra;
float start = static_cast<float>(letra_index) * step;
float end = start + duration_per_letra;
// Calcular temps per lletra
float duration_per_letra = 1.0f / static_cast<float>(num_letras);
float step = threshold * duration_per_letra;
float start = static_cast<float>(letra_index) * step;
float end = start + duration_per_letra;
// Interpolar progrés
if (global_progress < start) {
return 0.0f; // Encara no ha començat
} else if (global_progress >= end) {
return 1.0f; // Completament apareguda
} else {
return (global_progress - start) / (end - start);
}
// Interpolar progrés
if (global_progress < start) {
return 0.0f; // Encara no ha començat
} else if (global_progress >= end) {
return 1.0f; // Completament apareguda
} else {
return (global_progress - start) / (end - start);
}
}
EscenaLogo::EscenaLogo(SDLManager &sdl)
: sdl_(sdl), estat_actual_(EstatAnimacio::PRE_ANIMATION),
temps_estat_actual_(0.0f) {
std::cout << "Escena Logo: Inicialitzant...\n";
inicialitzar_lletres();
EscenaLogo::EscenaLogo(SDLManager& sdl)
: sdl_(sdl),
estat_actual_(EstatAnimacio::PRE_ANIMATION),
temps_estat_actual_(0.0f),
debris_manager_(std::make_unique<Effects::DebrisManager>(sdl.obte_renderer())),
lletra_explosio_index_(0),
temps_des_ultima_explosio_(0.0f) {
std::cout << "Escena Logo: Inicialitzant...\n";
inicialitzar_lletres();
}
void EscenaLogo::executar() {
SDL_Event event;
Uint64 last_time = SDL_GetTicks();
SDL_Event event;
Uint64 last_time = SDL_GetTicks();
while (GestorEscenes::actual == GestorEscenes::Escena::LOGO) {
// Calcular delta_time real
Uint64 current_time = SDL_GetTicks();
float delta_time = (current_time - last_time) / 1000.0f;
last_time = current_time;
while (GestorEscenes::actual == GestorEscenes::Escena::LOGO) {
// 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;
// Limitar delta_time per evitar grans salts
if (delta_time > 0.05f) {
delta_time = 0.05f;
}
// Processar events SDL
while (SDL_PollEvent(&event)) {
// Manejo de finestra
if (sdl_.handleWindowEvent(event)) {
continue;
}
// Events globals (F1/F2/F3/ESC/QUIT)
if (GlobalEvents::handle(event, sdl_)) {
continue;
}
// Processar events de l'escena (qualsevol tecla/clic salta al joc)
processar_events(event);
}
// Actualitzar lògica
actualitzar(delta_time);
// Actualitzar colors oscil·lats (efecte verd global)
sdl_.updateColors(delta_time);
// Dibuixar
dibuixar();
}
// Processar events SDL
while (SDL_PollEvent(&event)) {
// Manejo de finestra
if (sdl_.handleWindowEvent(event)) {
continue;
}
// Events globals (F1/F2/F3/ESC/QUIT)
if (GlobalEvents::handle(event, sdl_)) {
continue;
}
// Processar events de l'escena (qualsevol tecla/clic salta al joc)
processar_events(event);
}
// Actualitzar lògica
actualitzar(delta_time);
// Actualitzar colors oscil·lats (efecte verd global)
sdl_.updateColors(delta_time);
// Dibuixar
dibuixar();
}
std::cout << "Escena Logo: Finalitzant...\n";
std::cout << "Escena Logo: Finalitzant...\n";
}
void EscenaLogo::inicialitzar_lletres() {
using namespace Graphics;
using namespace Graphics;
// Llista de fitxers .shp (A repetida per a les dues A's)
std::vector<std::string> fitxers = {
"logo/letra_j.shp", "logo/letra_a.shp", "logo/letra_i.shp",
"logo/letra_l.shp", "logo/letra_g.shp", "logo/letra_a.shp",
"logo/letra_m.shp", "logo/letra_e.shp", "logo/letra_s.shp"};
// Llista de fitxers .shp (A repetida per a les dues A's)
std::vector<std::string> fitxers = {
"logo/letra_j.shp",
"logo/letra_a.shp",
"logo/letra_i.shp",
"logo/letra_l.shp",
"logo/letra_g.shp",
"logo/letra_a.shp",
"logo/letra_m.shp",
"logo/letra_e.shp",
"logo/letra_s.shp"};
// Pas 1: Carregar totes les formes i calcular amplades
float ancho_total = 0.0f;
// Pas 1: Carregar totes les formes i calcular amplades
float ancho_total = 0.0f;
for (const auto &fitxer : fitxers) {
auto forma = ShapeLoader::load(fitxer);
if (!forma || !forma->es_valida()) {
std::cerr << "[EscenaLogo] Error carregant " << fitxer << std::endl;
continue;
for (const auto& fitxer : fitxers) {
auto forma = ShapeLoader::load(fitxer);
if (!forma || !forma->es_valida()) {
std::cerr << "[EscenaLogo] Error carregant " << fitxer << std::endl;
continue;
}
// Calcular bounding box de la forma (trobar ancho)
float min_x = FLT_MAX;
float max_x = -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);
}
}
float ancho_sin_escalar = max_x - min_x;
// IMPORTANT: Escalar ancho i offset amb ESCALA_FINAL
// per que les posicions finals coincideixin amb la mida real de les lletres
float ancho = ancho_sin_escalar * ESCALA_FINAL;
float offset_centre = (forma->get_centre().x - min_x) * ESCALA_FINAL;
lletres_.push_back({forma,
{0.0f, 0.0f}, // Posició es calcularà després
ancho,
offset_centre});
ancho_total += ancho;
}
// Calcular bounding box de la forma (trobar ancho)
float min_x = FLT_MAX;
float max_x = -FLT_MAX;
// Pas 2: Afegir espaiat entre lletres
ancho_total += ESPAI_ENTRE_LLETRES * (lletres_.size() - 1);
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);
}
// Pas 3: Calcular posició inicial (centrat horitzontal)
constexpr float PANTALLA_ANCHO = 640.0f;
constexpr float PANTALLA_ALTO = 480.0f;
float x_inicial = (PANTALLA_ANCHO - ancho_total) / 2.0f;
float y_centre = PANTALLA_ALTO / 2.0f;
// Pas 4: Assignar posicions a cada lletra
float x_actual = x_inicial;
for (auto& lletra : lletres_) {
// Posicionar el centre de la forma (shape_centre) en pantalla
// Usar offset_centre en lloc de ancho/2 perquè shape_centre
// pot no estar exactament al mig del bounding box
lletra.posicio.x = x_actual + lletra.offset_centre;
lletra.posicio.y = y_centre;
// Avançar per a següent lletra
x_actual += lletra.ancho + ESPAI_ENTRE_LLETRES;
}
float ancho_sin_escalar = max_x - min_x;
// IMPORTANT: Escalar ancho i offset amb ESCALA_FINAL
// per que les posicions finals coincideixin amb la mida real de les lletres
float ancho = ancho_sin_escalar * ESCALA_FINAL;
float offset_centre = (forma->get_centre().x - min_x) * ESCALA_FINAL;
lletres_.push_back({forma,
{0.0f, 0.0f}, // Posició es calcularà després
ancho,
offset_centre});
ancho_total += ancho;
}
// Pas 2: Afegir espaiat entre lletres
ancho_total += ESPAI_ENTRE_LLETRES * (lletres_.size() - 1);
// Pas 3: Calcular posició inicial (centrat horitzontal)
constexpr float PANTALLA_ANCHO = 640.0f;
constexpr float PANTALLA_ALTO = 480.0f;
float x_inicial = (PANTALLA_ANCHO - ancho_total) / 2.0f;
float y_centre = PANTALLA_ALTO / 2.0f;
// Pas 4: Assignar posicions a cada lletra
float x_actual = x_inicial;
for (auto &lletra : lletres_) {
// Posicionar el centre de la forma (shape_centre) en pantalla
// Usar offset_centre en lloc de ancho/2 perquè shape_centre
// pot no estar exactament al mig del bounding box
lletra.posicio.x = x_actual + lletra.offset_centre;
lletra.posicio.y = y_centre;
// Avançar per a següent lletra
x_actual += lletra.ancho + ESPAI_ENTRE_LLETRES;
}
std::cout << "[EscenaLogo] " << lletres_.size()
<< " lletres carregades, ancho total: " << ancho_total << " px\n";
std::cout << "[EscenaLogo] " << lletres_.size()
<< " lletres carregades, ancho total: " << ancho_total << " px\n";
}
void EscenaLogo::canviar_estat(EstatAnimacio nou_estat) {
estat_actual_ = nou_estat;
temps_estat_actual_ = 0.0f; // Reset temps
std::cout << "[EscenaLogo] Canvi a estat: " << static_cast<int>(nou_estat)
<< "\n";
estat_actual_ = nou_estat;
temps_estat_actual_ = 0.0f; // Reset temps
// Inicialitzar estat d'explosió
if (nou_estat == EstatAnimacio::EXPLOSION) {
lletra_explosio_index_ = 0;
temps_des_ultima_explosio_ = 0.0f;
}
std::cout << "[EscenaLogo] Canvi a estat: " << static_cast<int>(nou_estat)
<< "\n";
}
bool EscenaLogo::totes_lletres_completes() const {
// Quan global_progress = 1.0, totes les lletres tenen letra_progress = 1.0
return temps_estat_actual_ >= DURACIO_ZOOM;
// Quan global_progress = 1.0, totes les lletres tenen letra_progress = 1.0
return temps_estat_actual_ >= DURACIO_ZOOM;
}
void EscenaLogo::actualitzar_explosions(float delta_time) {
temps_des_ultima_explosio_ += delta_time;
// Comprovar si és el moment d'explotar la següent lletra
if (temps_des_ultima_explosio_ >= DELAY_ENTRE_EXPLOSIONS) {
if (lletra_explosio_index_ < lletres_.size()) {
// Explotar lletra actual
const auto& lletra = lletres_[lletra_explosio_index_];
debris_manager_->explotar(
lletra.forma, // Forma a explotar
lletra.posicio, // Posició
0.0f, // Angle (sense rotació)
ESCALA_FINAL, // Escala (lletres a escala final)
VELOCITAT_EXPLOSIO // Velocitat base
);
std::cout << "[EscenaLogo] Explota lletra " << lletra_explosio_index_ << "\n";
// Passar a la següent lletra
lletra_explosio_index_++;
temps_des_ultima_explosio_ = 0.0f;
} else {
// Totes les lletres han explotat, transició a POST_EXPLOSION
canviar_estat(EstatAnimacio::POST_EXPLOSION);
}
}
}
void EscenaLogo::actualitzar(float delta_time) {
temps_estat_actual_ += delta_time;
temps_estat_actual_ += delta_time;
switch (estat_actual_) {
case EstatAnimacio::PRE_ANIMATION:
if (temps_estat_actual_ >= DURACIO_PRE) {
canviar_estat(EstatAnimacio::ANIMATION);
}
break;
switch (estat_actual_) {
case EstatAnimacio::PRE_ANIMATION:
if (temps_estat_actual_ >= DURACIO_PRE) {
canviar_estat(EstatAnimacio::ANIMATION);
}
break;
case EstatAnimacio::ANIMATION:
if (totes_lletres_completes()) {
canviar_estat(EstatAnimacio::POST_ANIMATION);
}
break;
case EstatAnimacio::ANIMATION:
if (totes_lletres_completes()) {
canviar_estat(EstatAnimacio::POST_ANIMATION);
}
break;
case EstatAnimacio::POST_ANIMATION:
if (temps_estat_actual_ >= DURACIO_POST) {
GestorEscenes::actual = GestorEscenes::Escena::JOC;
case EstatAnimacio::POST_ANIMATION:
if (temps_estat_actual_ >= DURACIO_POST_ANIMATION) {
canviar_estat(EstatAnimacio::EXPLOSION);
}
break;
case EstatAnimacio::EXPLOSION:
actualitzar_explosions(delta_time);
break;
case EstatAnimacio::POST_EXPLOSION:
if (temps_estat_actual_ >= DURACIO_POST_EXPLOSION) {
GestorEscenes::actual = GestorEscenes::Escena::JOC;
}
break;
}
break;
}
// Actualitzar animacions de debris
debris_manager_->actualitzar(delta_time);
}
void EscenaLogo::dibuixar() {
// Fons negre
sdl_.neteja(0, 0, 0);
// Fons negre
sdl_.neteja(0, 0, 0);
// PRE_ANIMATION: Només pantalla negra
if (estat_actual_ == EstatAnimacio::PRE_ANIMATION) {
sdl_.presenta();
return; // No renderitzar lletres
}
// ANIMATION o POST_ANIMATION: Calcular progrés
float global_progress =
(estat_actual_ == EstatAnimacio::ANIMATION)
? std::min(temps_estat_actual_ / DURACIO_ZOOM, 1.0f)
: 1.0f; // POST: mantenir al 100%
// Punt inicial del zoom (configurable amb ORIGEN_ZOOM_X/Y)
const Punt ORIGEN_ZOOM = {ORIGEN_ZOOM_X, ORIGEN_ZOOM_Y};
// Dibuixar cada lletra amb animació seqüencial
for (size_t i = 0; i < lletres_.size(); i++) {
const auto &lletra = lletres_[i];
// Calcular progrés individual d'aquesta lletra (0.0 → 1.0)
float letra_progress = calcular_progress_letra(
i, lletres_.size(), global_progress, THRESHOLD_LETRA);
// Si la lletra encara no ha començat, saltar-la
if (letra_progress <= 0.0f) {
continue;
// PRE_ANIMATION: Només pantalla negra
if (estat_actual_ == EstatAnimacio::PRE_ANIMATION) {
sdl_.presenta();
return; // No renderitzar lletres
}
// Interpolar posició: des del origen zoom cap a posició final
Punt pos_actual;
pos_actual.x =
ORIGEN_ZOOM.x + (lletra.posicio.x - ORIGEN_ZOOM.x) * letra_progress;
pos_actual.y =
ORIGEN_ZOOM.y + (lletra.posicio.y - ORIGEN_ZOOM.y) * letra_progress;
// ANIMATION o POST_ANIMATION: Dibuixar lletres amb animació
if (estat_actual_ == EstatAnimacio::ANIMATION ||
estat_actual_ == EstatAnimacio::POST_ANIMATION) {
float global_progress =
(estat_actual_ == EstatAnimacio::ANIMATION)
? std::min(temps_estat_actual_ / DURACIO_ZOOM, 1.0f)
: 1.0f; // POST: mantenir al 100%
// Aplicar ease-out quadràtic per suavitat
float t = letra_progress;
float ease_factor = 1.0f - (1.0f - t) * (1.0f - t);
const Punt ORIGEN_ZOOM = {ORIGEN_ZOOM_X, ORIGEN_ZOOM_Y};
// Interpolar escala amb ease-out: des de ESCALA_INICIAL cap a ESCALA_FINAL
float escala_actual =
ESCALA_INICIAL + (ESCALA_FINAL - ESCALA_INICIAL) * ease_factor;
for (size_t i = 0; i < lletres_.size(); i++) {
const auto& lletra = lletres_[i];
// Renderitzar la lletra
Rendering::render_shape(
sdl_.obte_renderer(), lletra.forma,
pos_actual, // Posició interpolada
0.0f, // Sense rotació
escala_actual, // Escala interpolada amb ease-out
true, // Dibuixar
1.0f // Progress = 1.0 (lletra completa, sense animació de primitives)
);
}
float letra_progress = calcular_progress_letra(
i,
lletres_.size(),
global_progress,
THRESHOLD_LETRA);
sdl_.presenta();
if (letra_progress <= 0.0f) {
continue;
}
Punt pos_actual;
pos_actual.x =
ORIGEN_ZOOM.x + (lletra.posicio.x - ORIGEN_ZOOM.x) * letra_progress;
pos_actual.y =
ORIGEN_ZOOM.y + (lletra.posicio.y - ORIGEN_ZOOM.y) * letra_progress;
float t = letra_progress;
float ease_factor = 1.0f - (1.0f - t) * (1.0f - t);
float escala_actual =
ESCALA_INICIAL + (ESCALA_FINAL - ESCALA_INICIAL) * ease_factor;
Rendering::render_shape(
sdl_.obte_renderer(),
lletra.forma,
pos_actual,
0.0f,
escala_actual,
true,
1.0f);
}
}
// EXPLOSION: Dibuixar només lletres que encara no han explotat
if (estat_actual_ == EstatAnimacio::EXPLOSION) {
for (size_t i = lletra_explosio_index_; i < lletres_.size(); i++) {
const auto& lletra = lletres_[i];
Rendering::render_shape(
sdl_.obte_renderer(),
lletra.forma,
lletra.posicio,
0.0f,
ESCALA_FINAL,
true,
1.0f);
}
}
// POST_EXPLOSION: No dibuixar lletres, només debris (a baix)
// Sempre dibuixar debris (si n'hi ha d'actius)
debris_manager_->dibuixar();
sdl_.presenta();
}
void EscenaLogo::processar_events(const SDL_Event &event) {
// Qualsevol tecla o clic de ratolí salta al joc
if (event.type == SDL_EVENT_KEY_DOWN ||
event.type == SDL_EVENT_MOUSE_BUTTON_DOWN) {
GestorEscenes::actual = GestorEscenes::Escena::JOC;
}
void EscenaLogo::processar_events(const SDL_Event& event) {
// Qualsevol tecla o clic de ratolí salta al joc
if (event.type == SDL_EVENT_KEY_DOWN ||
event.type == SDL_EVENT_MOUSE_BUTTON_DOWN) {
GestorEscenes::actual = GestorEscenes::Escena::JOC;
}
}

109
source/game/escenes/escena_logo.hpp
View File

@@ -4,66 +4,77 @@
#pragma once
#include "../../core/graphics/shape.hpp"
#include "../../core/rendering/sdl_manager.hpp"
#include "../../core/types.hpp"
#include <SDL3/SDL.h>
#include <memory>
#include <vector>
#include "../../core/graphics/shape.hpp"
#include "../../core/rendering/sdl_manager.hpp"
#include "../../core/types.hpp"
#include "../effects/debris_manager.hpp"
class EscenaLogo {
public:
explicit EscenaLogo(SDLManager &sdl);
void executar(); // Bucle principal de l'escena
public:
explicit EscenaLogo(SDLManager& sdl);
void executar(); // Bucle principal de l'escena
private:
// Màquina d'estats per l'animació
enum class EstatAnimacio {
PRE_ANIMATION, // Pantalla negra inicial
ANIMATION, // Animació de zoom de lletres
POST_ANIMATION // Logo complet visible
};
private:
// Màquina d'estats per l'animació
enum class EstatAnimacio {
PRE_ANIMATION, // Pantalla negra inicial
ANIMATION, // Animació de zoom de lletres
POST_ANIMATION, // Logo complet visible
EXPLOSION, // Explosió seqüencial de lletres
POST_EXPLOSION // Espera després de l'última explosió
};
SDLManager &sdl_;
EstatAnimacio estat_actual_; // Estat actual de la màquina
float
temps_estat_actual_; // Temps en l'estat actual (reset en cada transició)
SDLManager& sdl_;
EstatAnimacio estat_actual_; // Estat actual de la màquina
float
temps_estat_actual_; // Temps en l'estat actual (reset en cada transició)
// Estructura per a cada lletra del logo
struct LetraLogo {
std::shared_ptr<Graphics::Shape> forma;
Punt posicio; // Posició final en pantalla
float ancho; // Ancho del bounding box
float offset_centre; // Distància de min_x a shape_centre.x
};
// Gestor de fragments d'explosions
std::unique_ptr<Effects::DebrisManager> debris_manager_;
std::vector<LetraLogo> lletres_; // 9 lletres: J-A-I-L-G-A-M-E-S
// Seguiment d'explosions seqüencials
size_t lletra_explosio_index_; // Índex de la següent lletra a explotar
float temps_des_ultima_explosio_; // Temps des de l'última explosió
// Constants d'animació
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 =
4.0f; // Duració POST_ANIMATION (logo complet)
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
// Estructura per a cada lletra del logo
struct LetraLogo {
std::shared_ptr<Graphics::Shape> forma;
Punt posicio; // Posició final en pantalla
float ancho; // Ancho del bounding box
float offset_centre; // Distància de min_x a shape_centre.x
};
// Constants d'animació seqüencial
static constexpr float THRESHOLD_LETRA =
0.6f; // Umbral per activar següent lletra (0.0-1.0)
static constexpr float ORIGEN_ZOOM_X =
640.0f / 2.0f; // Punt inicial X del zoom (320)
static constexpr float ORIGEN_ZOOM_Y =
480.0f * 0.4f; // Punt inicial Y del zoom (240)
std::vector<LetraLogo> lletres_; // 9 lletres: J-A-I-L-G-A-M-E-S
// Mètodes privats
void inicialitzar_lletres();
void actualitzar(float delta_time);
void dibuixar();
void processar_events(const SDL_Event &event);
// Constants d'animació
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 = 1.0f; // Temps entre explosions de lletres
static constexpr float VELOCITAT_EXPLOSIO = 80.0f; // Velocitat 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
// Mètodes de gestió d'estats
void canviar_estat(EstatAnimacio nou_estat);
bool totes_lletres_completes() const;
// Constants d'animació seqüencial
static constexpr float THRESHOLD_LETRA = 0.6f; // Umbral per activar següent lletra (0.0-1.0)
static constexpr float ORIGEN_ZOOM_X = 640.0f / 2.0f; // Punt inicial X del zoom (320)
static constexpr float ORIGEN_ZOOM_Y = 480.0f * 0.4f; // Punt inicial Y del zoom (240)
// Mètodes privats
void inicialitzar_lletres();
void actualitzar(float delta_time);
void actualitzar_explosions(float delta_time);
void dibuixar();
void processar_events(const SDL_Event& event);
// Mètodes de gestió d'estats
void canviar_estat(EstatAnimacio nou_estat);
bool totes_lletres_completes() const;
};