JailDesigner
816bc02d9d
GameScene::actualitzar_continue, processar_input_continue y el
helper check_and_apply_continue_timeout (3 funciones, ~140 LOC) salen
a Systems::ContinueScreen en source/game/systems/continue_system.{hpp,cpp}.
API:
- struct Systems::ContinueScreen::Context: agrupa el estado mutable
(state, counter, tick_timer, continues_used, game_over_timer,
lives/score/hit_timer arrays, ships, match_config) y un callback
get_spawn_point inyectado por GameScene.
- update(ctx, dt): avanza countdown automatico y transiciona a
GAME_OVER si timeout.
- processInput(ctx): START revive jugador(es), THRUST/SHOOT acelera
countdown.
Helpers privados (revivePlayer, checkAndApplyTimeout) en anonymous
namespace del .cpp para evitar contaminar el header.
GameOverState ahora con underlying type explicito (uint8_t) para
permitir forward-declaration limpia en continue_system.hpp.
dibuixar_continue y unir_jugador se quedan en GameScene (render y
gameplay normal, no parte del state machine).
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
1179 lines
45 KiB
C++
1179 lines
45 KiB
C++
// game_scene.cpp - Implementació de la lógica del juego
|
|
// © 1999 Visente i Sergi (versión Pascal)
|
|
// © 2025 Port a C++20 con SDL3
|
|
|
|
#include "game_scene.hpp"
|
|
|
|
#include <algorithm>
|
|
#include <cmath>
|
|
#include <cstdlib>
|
|
#include <ctime>
|
|
#include <iostream>
|
|
#include <vector>
|
|
|
|
#include "core/audio/audio.hpp"
|
|
#include "core/entities/entity.hpp"
|
|
#include "core/input/input.hpp"
|
|
#include "core/input/mouse.hpp"
|
|
#include "core/math/easing.hpp"
|
|
#include "core/physics/collision.hpp"
|
|
#include "core/rendering/line_renderer.hpp"
|
|
#include "core/system/scene_context.hpp"
|
|
#include "core/system/global_events.hpp"
|
|
#include "game/stage_system/stage_loader.hpp"
|
|
#include "game/systems/collision_system.hpp"
|
|
#include "game/systems/continue_system.hpp"
|
|
|
|
// Using declarations per simplificar el codi
|
|
using SceneManager::SceneContext;
|
|
using SceneType = SceneContext::SceneType;
|
|
using Option = SceneContext::Option;
|
|
|
|
GameScene::GameScene(SDLManager& sdl, SceneContext& context)
|
|
: sdl_(sdl),
|
|
context_(context),
|
|
debris_manager_(sdl.getRenderer()),
|
|
floating_score_manager_(sdl.getRenderer()),
|
|
text_(sdl.getRenderer()),
|
|
init_hud_rect_sound_played_(false) {
|
|
// Recuperar configuración de match des del context
|
|
match_config_ = context_.getMatchConfig();
|
|
|
|
// Debug output de la configuración
|
|
std::cout << "[GameScene] Configuración de match - P1: "
|
|
<< (match_config_.jugador1_actiu ? "ACTIU" : "INACTIU")
|
|
<< ", P2: "
|
|
<< (match_config_.jugador2_actiu ? "ACTIU" : "INACTIU")
|
|
<< '\n';
|
|
|
|
// Consumir opciones (preparació per MODE_DEMO futur)
|
|
auto option = context_.consumeOption();
|
|
(void)option; // Suprimir warning de variable no usada
|
|
|
|
// Inicialitzar naves con renderer (P1=ship.shp, P2=ship2.shp)
|
|
ships_[0] = Ship(sdl.getRenderer(), "ship.shp"); // Jugador 1: nave estàndar
|
|
ships_[1] = Ship(sdl.getRenderer(), "ship2.shp"); // Jugador 2: interceptor con ales
|
|
|
|
// Inicialitzar balas con renderer
|
|
for (auto& bullet : bullets_) {
|
|
bullet = Bullet(sdl.getRenderer());
|
|
}
|
|
|
|
// Inicialitzar enemigos con renderer
|
|
for (auto& enemy : enemies_) {
|
|
enemy = Enemy(sdl.getRenderer());
|
|
}
|
|
}
|
|
|
|
void GameScene::run() {
|
|
std::cout << "SceneType Juego: Inicialitzant...\n";
|
|
|
|
// Inicialitzar state del juego
|
|
init();
|
|
|
|
SDL_Event event;
|
|
Uint64 last_time = SDL_GetTicks();
|
|
|
|
while (SceneManager::actual == SceneType::GAME) {
|
|
// 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 grandes salts
|
|
delta_time = std::min(delta_time, 0.05F);
|
|
|
|
// Actualitzar counter de FPS
|
|
sdl_.updateFPS(delta_time);
|
|
|
|
// Actualitzar visibilitat del cursor (auto-ocultar)
|
|
Mouse::updateCursorVisibility();
|
|
|
|
// Actualitzar sistema de input ABANS del event loop
|
|
Input::get()->update();
|
|
|
|
// Processar events SDL
|
|
while (SDL_PollEvent(&event)) {
|
|
// Manejo de finestra
|
|
if (sdl_.handleWindowEvent(event)) {
|
|
continue;
|
|
}
|
|
|
|
// Events globals (F1/F2/F3/ESC/QUIT)
|
|
GlobalEvents::handle(event, sdl_, context_);
|
|
}
|
|
|
|
// Actualitzar física del juego con delta_time real
|
|
update(delta_time);
|
|
|
|
// Actualitzar sistema de audio
|
|
Audio::update();
|
|
|
|
// Actualitzar colors oscil·lats
|
|
sdl_.updateColors(delta_time);
|
|
|
|
// Netejar pantalla (usa color oscil·lat)
|
|
sdl_.clear(0, 0, 0);
|
|
|
|
// Actualitzar context de renderizado (factor de scale global)
|
|
sdl_.updateRenderingContext();
|
|
|
|
// Dibuixar juego
|
|
draw();
|
|
|
|
// Presentar renderer (swap buffers)
|
|
sdl_.present();
|
|
}
|
|
|
|
std::cout << "SceneType Juego: Finalitzant...\n";
|
|
}
|
|
|
|
void GameScene::init() {
|
|
// Inicialitzar generador de números aleatoris
|
|
// Basat en el codi Pascal original: line 376
|
|
std::srand(static_cast<unsigned>(std::time(nullptr)));
|
|
|
|
// Configurar el mundo físico con los límites de la zona de juego.
|
|
// Las entidades se registrarán cada una al inicializarse (Fase 6c-e).
|
|
physics_world_.clear();
|
|
physics_world_.setBounds(Defaults::Zones::PLAYAREA);
|
|
|
|
// [NEW] Load stage configuration (only once)
|
|
if (!stage_config_) {
|
|
stage_config_ = StageSystem::StageLoader::load("data/stages/stages.yaml");
|
|
if (!stage_config_) {
|
|
std::cerr << "[GameScene] Error: no s'ha pogut load stages.yaml" << '\n';
|
|
// Continue without stage system (will crash, but helps debugging)
|
|
}
|
|
}
|
|
|
|
// [NEW] Initialize stage manager
|
|
stage_manager_ = std::make_unique<StageSystem::StageManager>(stage_config_.get());
|
|
stage_manager_->init();
|
|
|
|
// [NEW] Set ship position reference for safe spawn (P1 for now, TODO: dual tracking)
|
|
stage_manager_->getSpawnController().setShipPosition(&ships_[0].getCenter());
|
|
|
|
// Inicialitzar timers de muerte per player
|
|
hit_timer_per_player_[0] = 0.0F;
|
|
hit_timer_per_player_[1] = 0.0F;
|
|
|
|
// Initialize lives and game over state (independent lives per player)
|
|
lives_per_player_[0] = Defaults::Game::STARTING_LIVES;
|
|
lives_per_player_[1] = Defaults::Game::STARTING_LIVES;
|
|
game_over_state_ = GameOverState::NONE;
|
|
continue_counter_ = 0;
|
|
continue_tick_timer_ = 0.0F;
|
|
continues_used_ = 0;
|
|
game_over_timer_ = 0.0F;
|
|
|
|
// Initialize scores (separate per player)
|
|
score_per_player_[0] = 0;
|
|
score_per_player_[1] = 0;
|
|
floating_score_manager_.reset();
|
|
|
|
// DEPRECATED: spawn_position_ ya no s'usa, es calcula dinàmicament con obtenir_punt_spawn(player_id)
|
|
// const SDL_FRect& zona = Defaults::Zones::PLAYAREA;
|
|
// spawn_position_.x = zona.x + zona.w * 0.5f;
|
|
// spawn_position_.y = zona.y + zona.h * Defaults::Game::INIT_HUD_SHIP_START_Y_RATIO;
|
|
|
|
// Inicialitzar naves segons configuración (solo jugadors active)
|
|
for (uint8_t i = 0; i < 2; i++) {
|
|
bool jugador_actiu = (i == 0) ? match_config_.jugador1_actiu : match_config_.jugador2_actiu;
|
|
|
|
if (jugador_actiu) {
|
|
// Jugador active: init normalment
|
|
Vec2 spawn_pos = obtenir_punt_spawn(i);
|
|
ships_[i].init(&spawn_pos, false); // No invulnerability at start
|
|
// Registrar el cuerpo físico de la nave en el mundo (Fase 6c)
|
|
physics_world_.addBody(&ships_[i].getBody());
|
|
std::cout << "[GameScene] Jugador " << (i + 1) << " inicialitzat\n";
|
|
} else {
|
|
// Jugador inactiu: marcar como a mort permanent
|
|
ships_[i].markHit();
|
|
hit_timer_per_player_[i] = 999.0F; // Valor sentinella (permanent inactiu)
|
|
lives_per_player_[i] = 0; // Sin vides
|
|
std::cout << "[GameScene] Jugador " << (i + 1) << " inactiu\n";
|
|
}
|
|
}
|
|
|
|
// [MODIFIED] Initialize enemies as inactive (stage system will spawn them).
|
|
// Registramos el body al world incluso inactivo: con radius=0 no colisiona
|
|
// ni se mueve, y al init() del stage system se activa sin re-registrar.
|
|
for (auto& enemy : enemies_) {
|
|
enemy = Enemy(sdl_.getRenderer());
|
|
enemy.setShipPosition(&ships_[0].getCenter()); // Set ship reference (P1 for now)
|
|
physics_world_.addBody(&enemy.getBody());
|
|
// DON'T call enemy.init() here - stage system handles spawning
|
|
}
|
|
|
|
// Inicialitzar balas (now 6 instead of 3).
|
|
// Se registran en el physics_world para integración cinemática.
|
|
// Como su body_.radius=0, no colisionan físicamente con nadie (las
|
|
// colisiones de gameplay se gestionan en detectar_col·lisions_*).
|
|
for (auto& bullet : bullets_) {
|
|
bullet.init();
|
|
physics_world_.addBody(&bullet.getBody());
|
|
}
|
|
|
|
// [ELIMINAT] Iniciar música de juego (ara es gestiona en stage_manager)
|
|
// La música s'inicia cuando es transiciona de INIT_HUD a LEVEL_START
|
|
// Audio::get()->playMusic("game.ogg");
|
|
|
|
// Reset flag de sons de animación
|
|
init_hud_rect_sound_played_ = false;
|
|
}
|
|
|
|
void GameScene::update(float delta_time) {
|
|
// === FÍSICA: integrar bodies del frame anterior y resolver colisiones ===
|
|
// Se ejecuta al inicio del frame: las fuerzas aplicadas en el frame N-1
|
|
// por processInput/AI se integran ahora, y postUpdate sincroniza los
|
|
// mirrors (center_/angle_) antes de la lógica de juego que los lee.
|
|
physics_world_.update(delta_time);
|
|
for (auto& ship : ships_) {
|
|
ship.postUpdate(delta_time);
|
|
}
|
|
for (auto& enemy : enemies_) {
|
|
enemy.postUpdate(delta_time);
|
|
}
|
|
for (auto& bullet : bullets_) {
|
|
bullet.postUpdate(delta_time);
|
|
}
|
|
|
|
// Processar disparos (state-based, no event-based)
|
|
if (game_over_state_ == GameOverState::NONE) {
|
|
auto* input = Input::get();
|
|
|
|
// Jugador 1 dispara (solo si está active)
|
|
if (match_config_.jugador1_actiu) {
|
|
if (input->checkActionPlayer1(InputAction::SHOOT, Input::DO_NOT_ALLOW_REPEAT)) {
|
|
disparar_bala(0);
|
|
}
|
|
}
|
|
|
|
// Jugador 2 dispara (solo si está active)
|
|
if (match_config_.jugador2_actiu) {
|
|
if (input->checkActionPlayer2(InputAction::SHOOT, Input::DO_NOT_ALLOW_REPEAT)) {
|
|
disparar_bala(1);
|
|
}
|
|
}
|
|
|
|
// [FIXED] Allow mid-game join: inactive or dead player presses START
|
|
// Only during PLAYING state (not INIT_HUD, CONTINUE, GAME_OVER)
|
|
if (stage_manager_->get_estat() == StageSystem::EstatStage::PLAYING) {
|
|
// Check if at least one player is alive and playing (game in progress)
|
|
bool algun_jugador_viu = false;
|
|
if (match_config_.jugador1_actiu && hit_timer_per_player_[0] != 999.0F) {
|
|
algun_jugador_viu = true;
|
|
}
|
|
if (match_config_.jugador2_actiu && hit_timer_per_player_[1] != 999.0F) {
|
|
algun_jugador_viu = true;
|
|
}
|
|
|
|
// Only allow join if there's an active game
|
|
if (algun_jugador_viu) {
|
|
// P2 can join if not currently playing (never joined OR dead without lives)
|
|
bool p2_no_juga = !match_config_.jugador2_actiu || // Never joined
|
|
hit_timer_per_player_[1] == 999.0F; // Dead without lives
|
|
|
|
if (p2_no_juga) {
|
|
if (input->checkActionPlayer2(InputAction::START, Input::DO_NOT_ALLOW_REPEAT)) {
|
|
unir_jugador(1);
|
|
}
|
|
}
|
|
|
|
// P1 can join if not currently playing (never joined OR dead without lives)
|
|
bool p1_no_juga = !match_config_.jugador1_actiu || // Never joined
|
|
hit_timer_per_player_[0] == 999.0F; // Dead without lives
|
|
|
|
if (p1_no_juga) {
|
|
if (input->checkActionPlayer1(InputAction::START, Input::DO_NOT_ALLOW_REPEAT)) {
|
|
unir_jugador(0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Handle CONTINUE screen
|
|
if (game_over_state_ == GameOverState::CONTINUE) {
|
|
Systems::ContinueScreen::Context cont_ctx{
|
|
.state = game_over_state_,
|
|
.counter = continue_counter_,
|
|
.tick_timer = continue_tick_timer_,
|
|
.continues_used = continues_used_,
|
|
.game_over_timer = game_over_timer_,
|
|
.lives_per_player = lives_per_player_,
|
|
.score_per_player = score_per_player_,
|
|
.hit_timer_per_player = hit_timer_per_player_,
|
|
.ships = ships_,
|
|
.match_config = match_config_,
|
|
.get_spawn_point = [this](uint8_t pid) { return obtenir_punt_spawn(pid); },
|
|
};
|
|
Systems::ContinueScreen::update(cont_ctx, delta_time);
|
|
Systems::ContinueScreen::processInput(cont_ctx);
|
|
|
|
// Still update enemies, bullets, and effects during continue screen
|
|
for (auto& enemy : enemies_) {
|
|
enemy.update(delta_time);
|
|
}
|
|
for (auto& bullet : bullets_) {
|
|
bullet.update(delta_time);
|
|
}
|
|
debris_manager_.update(delta_time);
|
|
floating_score_manager_.update(delta_time);
|
|
return;
|
|
}
|
|
|
|
// Handle final GAME OVER state
|
|
if (game_over_state_ == GameOverState::GAME_OVER) {
|
|
// Game over: only update timer, enemies, bullets, and debris
|
|
game_over_timer_ -= delta_time;
|
|
|
|
if (game_over_timer_ <= 0.0F) {
|
|
// Aturar música de juego antes de tornar al título
|
|
Audio::get()->stopMusic();
|
|
// Transición a pantalla de título
|
|
context_.setNextScene(SceneType::TITLE);
|
|
SceneManager::actual = SceneType::TITLE;
|
|
return;
|
|
}
|
|
|
|
// Enemies and bullets continue moving during game over
|
|
for (auto& enemy : enemies_) {
|
|
enemy.update(delta_time);
|
|
}
|
|
|
|
for (auto& bullet : bullets_) {
|
|
bullet.update(delta_time);
|
|
}
|
|
|
|
debris_manager_.update(delta_time);
|
|
floating_score_manager_.update(delta_time);
|
|
return;
|
|
}
|
|
|
|
// Check death sequence state for BOTH players
|
|
bool algun_jugador_mort = false;
|
|
for (uint8_t i = 0; i < 2; i++) {
|
|
if (hit_timer_per_player_[i] > 0.0F && hit_timer_per_player_[i] < 999.0F) {
|
|
algun_jugador_mort = true;
|
|
// Death sequence active: update timer
|
|
hit_timer_per_player_[i] += delta_time;
|
|
|
|
// Check if death duration completed (only trigger ONCE using sentinel value)
|
|
if (hit_timer_per_player_[i] >= Defaults::Game::DEATH_DURATION) {
|
|
// *** PHASE 3: RESPAWN OR GAME OVER ***
|
|
|
|
// Decrement lives for this player (only once)
|
|
lives_per_player_[i]--;
|
|
|
|
if (lives_per_player_[i] > 0) {
|
|
// Respawn ship en spawn position con invulnerabilidad
|
|
Vec2 spawn_pos = obtenir_punt_spawn(i);
|
|
ships_[i].init(&spawn_pos, true);
|
|
hit_timer_per_player_[i] = 0.0F;
|
|
} else {
|
|
// Player is permanently dead (out of lives)
|
|
// Set sentinel value to prevent re-entering this block
|
|
hit_timer_per_player_[i] = 999.0F;
|
|
|
|
// Check if ALL ACTIVE players are dead (trigger continue screen)
|
|
bool p1_dead = !match_config_.jugador1_actiu || lives_per_player_[0] <= 0;
|
|
bool p2_dead = !match_config_.jugador2_actiu || lives_per_player_[1] <= 0;
|
|
|
|
if (p1_dead && p2_dead) {
|
|
game_over_state_ = GameOverState::CONTINUE;
|
|
continue_counter_ = Defaults::Game::CONTINUE_COUNT_START;
|
|
continue_tick_timer_ = Defaults::Game::CONTINUE_TICK_DURATION;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// If any player is dead, still update enemies/bullets/effects
|
|
if (algun_jugador_mort) {
|
|
// Enemies and bullets continue moving during death sequence
|
|
for (auto& enemy : enemies_) {
|
|
enemy.update(delta_time);
|
|
}
|
|
|
|
for (auto& bullet : bullets_) {
|
|
bullet.update(delta_time);
|
|
}
|
|
|
|
debris_manager_.update(delta_time);
|
|
floating_score_manager_.update(delta_time);
|
|
|
|
// Don't return - allow alive players to continue playing
|
|
}
|
|
|
|
// *** STAGE SYSTEM STATE MACHINE ***
|
|
|
|
StageSystem::EstatStage state = stage_manager_->get_estat();
|
|
|
|
switch (state) {
|
|
case StageSystem::EstatStage::INIT_HUD: {
|
|
// Update stage manager timer (pot canviar l'state!)
|
|
stage_manager_->update(delta_time);
|
|
|
|
// [FIX] Si l'state ha canviat durante update(), salir immediatament
|
|
// per evitar recalcular la posición de la ship con el nuevo timer
|
|
if (stage_manager_->get_estat() != StageSystem::EstatStage::INIT_HUD) {
|
|
break;
|
|
}
|
|
|
|
// Calcular global progress (0.0 al inicio → 1.0 al final)
|
|
float global_progress = 1.0F - (stage_manager_->get_timer_transicio() / Defaults::Game::INIT_HUD_DURATION);
|
|
global_progress = std::min(1.0F, global_progress);
|
|
|
|
// [NEW] Calcular progress independiente para cada nave
|
|
float ship1_progress = calcular_progress_rango(
|
|
global_progress,
|
|
Defaults::Game::INIT_HUD_SHIP1_RATIO_INIT,
|
|
Defaults::Game::INIT_HUD_SHIP1_RATIO_END);
|
|
|
|
float ship2_progress = calcular_progress_rango(
|
|
global_progress,
|
|
Defaults::Game::INIT_HUD_SHIP2_RATIO_INIT,
|
|
Defaults::Game::INIT_HUD_SHIP2_RATIO_END);
|
|
|
|
// [MODIFICAT] Animar AMBAS naves con sus progress respectivos
|
|
if (match_config_.jugador1_actiu && ship1_progress < 1.0F) {
|
|
Vec2 pos_p1 = calcular_posicio_nau_init_hud(ship1_progress, 0);
|
|
ships_[0].setCenter(pos_p1);
|
|
}
|
|
|
|
if (match_config_.jugador2_actiu && ship2_progress < 1.0F) {
|
|
Vec2 pos_p2 = calcular_posicio_nau_init_hud(ship2_progress, 1);
|
|
ships_[1].setCenter(pos_p2);
|
|
}
|
|
|
|
// Una vez l'animación acaba, permetre control normal
|
|
// pero mantenir la posición inicial especial hasta LEVEL_START
|
|
|
|
break;
|
|
}
|
|
|
|
case StageSystem::EstatStage::LEVEL_START: {
|
|
// [DEBUG] Log entrada a LEVEL_START
|
|
static bool first_entry = true;
|
|
if (first_entry) {
|
|
std::cout << "[LEVEL_START] ENTERED with P1 pos.y=" << ships_[0].getCenter().y << '\n';
|
|
first_entry = false;
|
|
}
|
|
|
|
// Update countdown timer
|
|
stage_manager_->update(delta_time);
|
|
|
|
// [NEW] Allow both ships movement and shooting during intro
|
|
for (uint8_t i = 0; i < 2; i++) {
|
|
bool jugador_actiu = (i == 0) ? match_config_.jugador1_actiu : match_config_.jugador2_actiu;
|
|
if (jugador_actiu && hit_timer_per_player_[i] == 0.0F) { // Only active, alive players
|
|
ships_[i].processInput(delta_time, i);
|
|
ships_[i].update(delta_time);
|
|
}
|
|
}
|
|
|
|
// [NEW] Update bullets
|
|
for (auto& bullet : bullets_) {
|
|
bullet.update(delta_time);
|
|
}
|
|
|
|
// [NEW] Update debris
|
|
debris_manager_.update(delta_time);
|
|
break;
|
|
}
|
|
|
|
case StageSystem::EstatStage::PLAYING: {
|
|
// [NEW] Update stage manager (spawns enemies, pause if BOTH dead)
|
|
bool pause_spawn = (hit_timer_per_player_[0] > 0.0F && hit_timer_per_player_[1] > 0.0F);
|
|
stage_manager_->getSpawnController().update(delta_time, enemies_, pause_spawn);
|
|
|
|
// [NEW] Check stage completion (only when at least one player alive)
|
|
bool algun_jugador_viu = (hit_timer_per_player_[0] == 0.0F || hit_timer_per_player_[1] == 0.0F);
|
|
if (algun_jugador_viu) {
|
|
auto& spawn_ctrl = stage_manager_->getSpawnController();
|
|
if (spawn_ctrl.tots_enemics_destruits(enemies_)) {
|
|
stage_manager_->stage_completat();
|
|
Audio::get()->playSound(Defaults::Sound::GOOD_JOB_COMMANDER, Audio::Group::GAME);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// [EXISTING] Normal gameplay - update active players
|
|
for (uint8_t i = 0; i < 2; i++) {
|
|
bool jugador_actiu = (i == 0) ? match_config_.jugador1_actiu : match_config_.jugador2_actiu;
|
|
if (jugador_actiu && hit_timer_per_player_[i] == 0.0F) { // Only active, alive players
|
|
ships_[i].processInput(delta_time, i);
|
|
ships_[i].update(delta_time);
|
|
}
|
|
}
|
|
|
|
for (auto& enemy : enemies_) {
|
|
enemy.update(delta_time);
|
|
}
|
|
|
|
for (auto& bullet : bullets_) {
|
|
bullet.update(delta_time);
|
|
}
|
|
|
|
{
|
|
Systems::Collision::Context col_ctx{
|
|
.ships = ships_,
|
|
.enemies = enemies_,
|
|
.bullets = bullets_,
|
|
.hit_timer_per_player = hit_timer_per_player_,
|
|
.score_per_player = score_per_player_,
|
|
.lives_per_player = lives_per_player_,
|
|
.debris_manager = debris_manager_,
|
|
.floating_score_manager = floating_score_manager_,
|
|
.match_config = match_config_,
|
|
.on_player_hit = [this](uint8_t pid) { tocado(pid); },
|
|
};
|
|
Systems::Collision::detectAll(col_ctx);
|
|
}
|
|
debris_manager_.update(delta_time);
|
|
floating_score_manager_.update(delta_time);
|
|
break;
|
|
}
|
|
|
|
case StageSystem::EstatStage::LEVEL_COMPLETED:
|
|
// Update countdown timer
|
|
stage_manager_->update(delta_time);
|
|
|
|
// [NEW] Allow both ships movement and shooting during outro
|
|
for (uint8_t i = 0; i < 2; i++) {
|
|
bool jugador_actiu = (i == 0) ? match_config_.jugador1_actiu : match_config_.jugador2_actiu;
|
|
if (jugador_actiu && hit_timer_per_player_[i] == 0.0F) { // Only active, alive players
|
|
ships_[i].processInput(delta_time, i);
|
|
ships_[i].update(delta_time);
|
|
}
|
|
}
|
|
|
|
// [NEW] Update bullets (allow last shots to continue)
|
|
for (auto& bullet : bullets_) {
|
|
bullet.update(delta_time);
|
|
}
|
|
|
|
// [NEW] Update debris (from last destroyed enemies)
|
|
debris_manager_.update(delta_time);
|
|
floating_score_manager_.update(delta_time);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void GameScene::draw() {
|
|
// Handle CONTINUE screen
|
|
if (game_over_state_ == GameOverState::CONTINUE) {
|
|
// Draw game background elements first
|
|
dibuixar_marges();
|
|
|
|
for (const auto& enemy : enemies_) {
|
|
enemy.draw();
|
|
}
|
|
|
|
for (const auto& bullet : bullets_) {
|
|
bullet.draw();
|
|
}
|
|
|
|
debris_manager_.draw();
|
|
floating_score_manager_.draw();
|
|
dibuixar_marcador();
|
|
|
|
// Draw CONTINUE screen overlay
|
|
dibuixar_continue();
|
|
return;
|
|
}
|
|
|
|
// Handle final GAME OVER state
|
|
if (game_over_state_ == GameOverState::GAME_OVER) {
|
|
// Game over: draw enemies, bullets, debris, and "GAME OVER" text
|
|
dibuixar_marges();
|
|
|
|
for (const auto& enemy : enemies_) {
|
|
enemy.draw();
|
|
}
|
|
|
|
for (const auto& bullet : bullets_) {
|
|
bullet.draw();
|
|
}
|
|
|
|
debris_manager_.draw();
|
|
floating_score_manager_.draw();
|
|
|
|
// Draw centered "GAME OVER" text
|
|
const std::string game_over_text = "GAME OVER";
|
|
constexpr float scale = Defaults::Game::GameOverScreen::TEXT_SCALE;
|
|
constexpr float spacing = Defaults::Game::GameOverScreen::TEXT_SPACING;
|
|
|
|
// Calcular centro de l'àrea de juego usant constants
|
|
const SDL_FRect& play_area = Defaults::Zones::PLAYAREA;
|
|
float centre_x = play_area.x + (play_area.w / 2.0F);
|
|
float centre_y = play_area.y + (play_area.h / 2.0F);
|
|
|
|
text_.renderCentered(game_over_text, {.x = centre_x, .y = centre_y}, scale, spacing);
|
|
|
|
dibuixar_marcador();
|
|
return;
|
|
}
|
|
|
|
// [NEW] Stage state rendering
|
|
StageSystem::EstatStage state = stage_manager_->get_estat();
|
|
|
|
switch (state) {
|
|
case StageSystem::EstatStage::INIT_HUD: {
|
|
// Calcular progrés de cada animación independent
|
|
float timer = stage_manager_->get_timer_transicio();
|
|
float total_time = Defaults::Game::INIT_HUD_DURATION;
|
|
float global_progress = 1.0F - (timer / total_time);
|
|
|
|
// [NEW] Calcular progress independiente para cada elemento
|
|
float rect_progress = calcular_progress_rango(
|
|
global_progress,
|
|
Defaults::Game::INIT_HUD_RECT_RATIO_INIT,
|
|
Defaults::Game::INIT_HUD_RECT_RATIO_END);
|
|
|
|
float score_progress = calcular_progress_rango(
|
|
global_progress,
|
|
Defaults::Game::INIT_HUD_SCORE_RATIO_INIT,
|
|
Defaults::Game::INIT_HUD_SCORE_RATIO_END);
|
|
|
|
float ship1_progress = calcular_progress_rango(
|
|
global_progress,
|
|
Defaults::Game::INIT_HUD_SHIP1_RATIO_INIT,
|
|
Defaults::Game::INIT_HUD_SHIP1_RATIO_END);
|
|
|
|
float ship2_progress = calcular_progress_rango(
|
|
global_progress,
|
|
Defaults::Game::INIT_HUD_SHIP2_RATIO_INIT,
|
|
Defaults::Game::INIT_HUD_SHIP2_RATIO_END);
|
|
|
|
// Dibuixar elements animats
|
|
if (rect_progress > 0.0F) {
|
|
// [NOU] Reproduir so cuando comença l'animación del rectangle
|
|
if (!init_hud_rect_sound_played_) {
|
|
Audio::get()->playSound(Defaults::Sound::INIT_HUD, Audio::Group::GAME);
|
|
init_hud_rect_sound_played_ = true;
|
|
}
|
|
|
|
dibuixar_marges_animat(rect_progress);
|
|
}
|
|
|
|
if (score_progress > 0.0F) {
|
|
dibuixar_marcador_animat(score_progress);
|
|
}
|
|
|
|
// [MODIFICAT] Dibuixar naves con progress independent
|
|
if (ship1_progress > 0.0F && match_config_.jugador1_actiu && !ships_[0].isHit()) {
|
|
ships_[0].draw();
|
|
}
|
|
|
|
if (ship2_progress > 0.0F && match_config_.jugador2_actiu && !ships_[1].isHit()) {
|
|
ships_[1].draw();
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case StageSystem::EstatStage::LEVEL_START:
|
|
dibuixar_marges();
|
|
// [NEW] Draw both ships if active and alive
|
|
for (uint8_t i = 0; i < 2; i++) {
|
|
bool jugador_actiu = (i == 0) ? match_config_.jugador1_actiu : match_config_.jugador2_actiu;
|
|
if (jugador_actiu && hit_timer_per_player_[i] == 0.0F) {
|
|
ships_[i].draw();
|
|
}
|
|
}
|
|
|
|
// [NEW] Draw bullets
|
|
for (const auto& bullet : bullets_) {
|
|
bullet.draw();
|
|
}
|
|
|
|
// [NEW] Draw debris
|
|
debris_manager_.draw();
|
|
floating_score_manager_.draw();
|
|
|
|
// [EXISTING] Draw intro message and score
|
|
dibuixar_missatge_stage(stage_manager_->get_missatge_level_start());
|
|
dibuixar_marcador();
|
|
break;
|
|
|
|
case StageSystem::EstatStage::PLAYING:
|
|
dibuixar_marges();
|
|
|
|
// [EXISTING] Normal rendering - active ships
|
|
for (uint8_t i = 0; i < 2; i++) {
|
|
bool jugador_actiu = (i == 0) ? match_config_.jugador1_actiu : match_config_.jugador2_actiu;
|
|
if (jugador_actiu && hit_timer_per_player_[i] == 0.0F) {
|
|
ships_[i].draw();
|
|
}
|
|
}
|
|
|
|
for (const auto& enemy : enemies_) {
|
|
enemy.draw();
|
|
}
|
|
|
|
for (const auto& bullet : bullets_) {
|
|
bullet.draw();
|
|
}
|
|
|
|
debris_manager_.draw();
|
|
floating_score_manager_.draw();
|
|
dibuixar_marcador();
|
|
break;
|
|
|
|
case StageSystem::EstatStage::LEVEL_COMPLETED:
|
|
dibuixar_marges();
|
|
// [NEW] Draw both ships if active and alive
|
|
for (uint8_t i = 0; i < 2; i++) {
|
|
bool jugador_actiu = (i == 0) ? match_config_.jugador1_actiu : match_config_.jugador2_actiu;
|
|
if (jugador_actiu && hit_timer_per_player_[i] == 0.0F) {
|
|
ships_[i].draw();
|
|
}
|
|
}
|
|
|
|
// [NEW] Draw bullets (allow last shots to be visible)
|
|
for (const auto& bullet : bullets_) {
|
|
bullet.draw();
|
|
}
|
|
|
|
// [NEW] Draw debris (from last destroyed enemies)
|
|
debris_manager_.draw();
|
|
floating_score_manager_.draw();
|
|
|
|
// [EXISTING] Draw completion message and score
|
|
dibuixar_missatge_stage(StageSystem::Constants::MISSATGE_LEVEL_COMPLETED);
|
|
dibuixar_marcador();
|
|
break;
|
|
}
|
|
}
|
|
|
|
void GameScene::tocado(uint8_t player_id) {
|
|
// Death sequence: 3 phases
|
|
// Phase 1: First call (hit_timer_per_player_[player_id] == 0) - trigger explosion
|
|
// Phase 2: Animation (0 < itocado_ < 3.0s) - debris animation
|
|
// Phase 3: Respawn or game over (itocado_ >= 3.0s) - handled in update()
|
|
|
|
if (hit_timer_per_player_[player_id] == 0.0F) {
|
|
// *** PHASE 1: TRIGGER DEATH ***
|
|
|
|
// Mark ship as dead (stops rendering and input)
|
|
ships_[player_id].markHit();
|
|
|
|
// Create ship explosion
|
|
const Vec2& ship_pos = ships_[player_id].getCenter();
|
|
float ship_angle = ships_[player_id].getAngle();
|
|
Vec2 vel_nau = ships_[player_id].getVelocityVector();
|
|
// Reduir a 80% la velocity heretada per la ship (més realista)
|
|
Vec2 vel_nau_80 = {.x = vel_nau.x * 0.8F, .y = vel_nau.y * 0.8F};
|
|
|
|
debris_manager_.explode(
|
|
ships_[player_id].getShape(), // Ship shape (3 lines)
|
|
ship_pos, // Center position
|
|
ship_angle, // Ship orientation
|
|
1.0F, // Normal scale
|
|
Defaults::Physics::Debris::VELOCITAT_BASE, // 80 px/s
|
|
ships_[player_id].getBrightness(), // Heredar brightness
|
|
vel_nau_80, // Heredar 80% velocity
|
|
0.0F, // Nave: trayectorias rectas (sin drotacio)
|
|
0.0F, // Sin herencia visual (rotación aleatoria)
|
|
Defaults::Sound::EXPLOSION2 // Sonido alternativo para la explosión
|
|
);
|
|
|
|
// Start death timer (non-zero to avoid re-triggering)
|
|
hit_timer_per_player_[player_id] = 0.001F;
|
|
}
|
|
// Phase 2 is automatic (debris updates in update())
|
|
// Phase 3 is handled in update() when hit_timer_per_player_ >= DEATH_DURATION
|
|
}
|
|
|
|
void GameScene::dibuixar_marges() const {
|
|
// Dibuixar rectangle de la zona de juego
|
|
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);
|
|
|
|
// 4 línies per formar el rectangle
|
|
Rendering::linea(sdl_.getRenderer(), x1, y1, x2, y1); // Top
|
|
Rendering::linea(sdl_.getRenderer(), x1, y2, x2, y2); // Bottom
|
|
Rendering::linea(sdl_.getRenderer(), x1, y1, x1, y2); // Left
|
|
Rendering::linea(sdl_.getRenderer(), x2, y1, x2, y2); // Right
|
|
}
|
|
|
|
void GameScene::dibuixar_marcador() {
|
|
// Construir text del marcador
|
|
std::string text = buildScoreboard();
|
|
|
|
// Parámetros de renderització
|
|
const float scale = 0.85F;
|
|
const float spacing = 0.0F;
|
|
|
|
// Calcular centro de la zona del marcador
|
|
const SDL_FRect& scoreboard = Defaults::Zones::SCOREBOARD;
|
|
float centre_x = scoreboard.w / 2.0F;
|
|
float centre_y = scoreboard.y + (scoreboard.h / 2.0F);
|
|
|
|
// Renderizar centrat
|
|
text_.renderCentered(text, {.x = centre_x, .y = centre_y}, scale, spacing);
|
|
}
|
|
|
|
void GameScene::dibuixar_marges_animat(float progress) const {
|
|
// Animación seqüencial del rectangle con efecte de "pinzell"
|
|
// Dos pinzells comencen al centro superior i baixen por los laterals
|
|
|
|
const SDL_FRect& zona = Defaults::Zones::PLAYAREA;
|
|
|
|
// Aplicar easing al progrés global
|
|
float eased_progress = Easing::ease_out_quad(progress);
|
|
|
|
// Coordenades del rectangle complet
|
|
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);
|
|
int cx = (x1 + x2) / 2;
|
|
|
|
// Dividir en 3 fases de 33% cada una
|
|
constexpr float PHASE_1_END = 0.33F;
|
|
constexpr float PHASE_2_END = 0.66F;
|
|
|
|
// --- FASE 1: Línies horitzontals superiors (0-33%) ---
|
|
if (eased_progress > 0.0F) {
|
|
float phase1_progress = std::min(eased_progress / PHASE_1_END, 1.0F);
|
|
|
|
// Línia izquierda: creix des del centro hacia l'izquierda
|
|
int x1_phase1 = static_cast<int>(cx - ((cx - x1) * phase1_progress));
|
|
Rendering::linea(sdl_.getRenderer(), cx, y1, x1_phase1, y1);
|
|
|
|
// Línia derecha: creix des del centro hacia la derecha
|
|
int x2_phase1 = static_cast<int>(cx + ((x2 - cx) * phase1_progress));
|
|
Rendering::linea(sdl_.getRenderer(), cx, y1, x2_phase1, y1);
|
|
}
|
|
|
|
// --- FASE 2: Línies verticals laterals (33-66%) ---
|
|
if (eased_progress > PHASE_1_END) {
|
|
float phase2_progress = std::min((eased_progress - PHASE_1_END) / (PHASE_2_END - PHASE_1_END), 1.0F);
|
|
|
|
// Línia izquierda: creix desde dalt hacia baix
|
|
int y2_phase2 = static_cast<int>(y1 + ((y2 - y1) * phase2_progress));
|
|
Rendering::linea(sdl_.getRenderer(), x1, y1, x1, y2_phase2);
|
|
|
|
// Línia derecha: creix desde dalt hacia baix
|
|
Rendering::linea(sdl_.getRenderer(), x2, y1, x2, y2_phase2);
|
|
}
|
|
|
|
// --- FASE 3: Línies horitzontals inferiors (66-100%) ---
|
|
if (eased_progress > PHASE_2_END) {
|
|
float phase3_progress = (eased_progress - PHASE_2_END) / (1.0F - PHASE_2_END);
|
|
|
|
// Línia izquierda: creix desde l'izquierda hacia el centro
|
|
int x_left_phase3 = static_cast<int>(x1 + ((cx - x1) * phase3_progress));
|
|
Rendering::linea(sdl_.getRenderer(), x1, y2, x_left_phase3, y2);
|
|
|
|
// Línia derecha: creix desde la derecha hacia el centro
|
|
int x_right_phase3 = static_cast<int>(x2 - ((x2 - cx) * phase3_progress));
|
|
Rendering::linea(sdl_.getRenderer(), x2, y2, x_right_phase3, y2);
|
|
}
|
|
}
|
|
|
|
void GameScene::dibuixar_marcador_animat(float progress) {
|
|
// Animación del marcador pujant desde baix con easing
|
|
|
|
// Calcular progrés con easing
|
|
float eased_progress = Easing::ease_out_quad(progress);
|
|
|
|
// Construir text
|
|
std::string text = buildScoreboard();
|
|
|
|
// Parámetros
|
|
const float scale = 0.85F;
|
|
const float spacing = 0.0F;
|
|
|
|
// Calcular centro de la zona del marcador
|
|
const SDL_FRect& scoreboard = Defaults::Zones::SCOREBOARD;
|
|
float centre_x = scoreboard.w / 2.0F;
|
|
float centre_y_final = scoreboard.y + (scoreboard.h / 2.0F);
|
|
|
|
// Posición Y inicial (offscreen, sota de la pantalla)
|
|
auto centre_y_inicial = static_cast<float>(Defaults::Game::HEIGHT);
|
|
|
|
// Interpolació con easing
|
|
float centre_y_animada = centre_y_inicial + ((centre_y_final - centre_y_inicial) * eased_progress);
|
|
|
|
// Renderizar centrat en posición animada
|
|
text_.renderCentered(text, {.x = centre_x, .y = centre_y_animada}, scale, spacing);
|
|
}
|
|
|
|
Vec2 GameScene::calcular_posicio_nau_init_hud(float progress, uint8_t player_id) const {
|
|
// Animación de la ship pujant desde baix con easing
|
|
// [MODIFICAT] Ambas naves usan ease_out_quad (desfase temporal via INIT/END)
|
|
|
|
// Aplicar easing (uniforme para ambas naves)
|
|
float eased_progress = Easing::ease_out_quad(progress);
|
|
|
|
const SDL_FRect& zona = Defaults::Zones::PLAYAREA;
|
|
|
|
// Calcular posición final segons player (reutilitza obtenir_punt_spawn)
|
|
Vec2 spawn_final = obtenir_punt_spawn(player_id);
|
|
float x_final = spawn_final.x;
|
|
float y_final = spawn_final.y;
|
|
|
|
// Y inicial: offscreen, 50px sota la zona de juego
|
|
float y_inicial = zona.y + zona.h + 50.0F;
|
|
|
|
// X no canvia (destí segons player_id)
|
|
// Y interpola con easing
|
|
float y_animada = y_inicial + ((y_final - y_inicial) * eased_progress);
|
|
|
|
return {.x = x_final, .y = y_animada};
|
|
}
|
|
|
|
float GameScene::calcular_progress_rango(float global_progress, float ratio_init, float ratio_end) const {
|
|
// Convierte global_progress (0.0→1.0) a element_progress usando ventana [INIT, END]
|
|
//
|
|
// Casos:
|
|
// - global_progress < INIT → 0.0 (no ha empezado)
|
|
// - global_progress > END → 1.0 (completado)
|
|
// - INIT ≤ global_progress ≤ END → interpola linealmente 0.0→1.0
|
|
|
|
// Validación de parámetros (evita división por cero)
|
|
if (ratio_init >= ratio_end) {
|
|
return (global_progress >= ratio_end) ? 1.0F : 0.0F;
|
|
}
|
|
|
|
if (global_progress < ratio_init) {
|
|
return 0.0F;
|
|
}
|
|
|
|
if (global_progress > ratio_end) {
|
|
return 1.0F;
|
|
}
|
|
|
|
// Normalizar rango [INIT, END] a [0.0, 1.0]
|
|
return (global_progress - ratio_init) / (ratio_end - ratio_init);
|
|
}
|
|
|
|
std::string GameScene::buildScoreboard() const {
|
|
// Puntuación P1 (6 dígits) - mostrar zeros si inactiu
|
|
std::string score_p1;
|
|
std::string vides_p1;
|
|
if (match_config_.jugador1_actiu) {
|
|
score_p1 = std::to_string(score_per_player_[0]);
|
|
score_p1 = std::string(6 - std::min(6, static_cast<int>(score_p1.length())), '0') + score_p1;
|
|
vides_p1 = (lives_per_player_[0] < 10)
|
|
? "0" + std::to_string(lives_per_player_[0])
|
|
: std::to_string(lives_per_player_[0]);
|
|
} else {
|
|
score_p1 = "000000";
|
|
vides_p1 = "00";
|
|
}
|
|
|
|
// Nivel (2 dígits)
|
|
uint8_t stage_num = stage_manager_->get_stage_actual();
|
|
std::string stage_str = (stage_num < 10) ? "0" + std::to_string(stage_num)
|
|
: std::to_string(stage_num);
|
|
|
|
// Puntuación P2 (6 dígits) - mostrar zeros si inactiu
|
|
std::string score_p2;
|
|
std::string vides_p2;
|
|
if (match_config_.jugador2_actiu) {
|
|
score_p2 = std::to_string(score_per_player_[1]);
|
|
score_p2 = std::string(6 - std::min(6, static_cast<int>(score_p2.length())), '0') + score_p2;
|
|
vides_p2 = (lives_per_player_[1] < 10)
|
|
? "0" + std::to_string(lives_per_player_[1])
|
|
: std::to_string(lives_per_player_[1]);
|
|
} else {
|
|
score_p2 = "000000";
|
|
vides_p2 = "00";
|
|
}
|
|
|
|
// Format: "123456 03 LEVEL 01 654321 02"
|
|
// Nota: dos espais entre seccions, mantenir ambdós slots siempre visibles
|
|
return score_p1 + " " + vides_p1 + " LEVEL " + stage_str + " " + score_p2 + " " + vides_p2;
|
|
}
|
|
|
|
// [NEW] Stage system helper methods
|
|
|
|
void GameScene::dibuixar_missatge_stage(const std::string& message) {
|
|
constexpr float escala_base = 1.0F;
|
|
constexpr float spacing = 2.0F;
|
|
|
|
const SDL_FRect& play_area = Defaults::Zones::PLAYAREA;
|
|
const float max_width = play_area.w * Defaults::Game::STAGE_MESSAGE_MAX_WIDTH_RATIO;
|
|
|
|
// ========== TYPEWRITER EFFECT (PARAMETRIZED) ==========
|
|
// Get state-specific timing configuration
|
|
float total_time;
|
|
float typing_ratio;
|
|
|
|
if (stage_manager_->get_estat() == StageSystem::EstatStage::LEVEL_START) {
|
|
total_time = Defaults::Game::LEVEL_START_DURATION;
|
|
typing_ratio = Defaults::Game::LEVEL_START_TYPING_RATIO;
|
|
} else { // LEVEL_COMPLETED
|
|
total_time = Defaults::Game::LEVEL_COMPLETED_DURATION;
|
|
typing_ratio = Defaults::Game::LEVEL_COMPLETED_TYPING_RATIO;
|
|
}
|
|
|
|
// Calculate progress from timer (0.0 at start → 1.0 at end)
|
|
float remaining_time = stage_manager_->get_timer_transicio();
|
|
float progress = 1.0F - (remaining_time / total_time);
|
|
|
|
// Determine how many characters to show
|
|
size_t visible_chars;
|
|
|
|
if (typing_ratio > 0.0F && progress < typing_ratio) {
|
|
// Typewriter phase: show partial text
|
|
float typing_progress = progress / typing_ratio; // Normalize to 0.0-1.0
|
|
visible_chars = static_cast<size_t>(message.length() * typing_progress);
|
|
if (visible_chars == 0 && progress > 0.0F) {
|
|
visible_chars = 1; // Show at least 1 character after first frame
|
|
}
|
|
} else {
|
|
// Display phase: show complete text
|
|
// (Either after typing phase, or immediately if typing_ratio == 0.0)
|
|
visible_chars = message.length();
|
|
}
|
|
|
|
// Create partial message (substring for typewriter)
|
|
std::string partial_message = message.substr(0, visible_chars);
|
|
// ===================================================
|
|
|
|
// Calculate text width at base scale (using FULL message for position calculation)
|
|
float text_width_at_base = text_.get_text_width(message, escala_base, spacing);
|
|
|
|
// Auto-scale if text exceeds max width
|
|
float scale = (text_width_at_base <= max_width)
|
|
? escala_base
|
|
: max_width / text_width_at_base;
|
|
|
|
// Recalculate dimensions with final scale (using FULL message for centering)
|
|
float full_text_width = text_.get_text_width(message, scale, spacing);
|
|
float text_height = text_.get_text_height(scale);
|
|
|
|
// Calculate position as if FULL text was there (for fixed position typewriter)
|
|
float x = play_area.x + ((play_area.w - full_text_width) / 2.0F);
|
|
float y = play_area.y + (play_area.h * Defaults::Game::STAGE_MESSAGE_Y_RATIO) - (text_height / 2.0F);
|
|
|
|
// Render only the partial message (typewriter effect)
|
|
Vec2 pos = {.x = x, .y = y};
|
|
text_.render(partial_message, pos, scale, spacing);
|
|
}
|
|
|
|
// ========================================
|
|
// Helper methods for 2-player support
|
|
// ========================================
|
|
|
|
Vec2 GameScene::obtenir_punt_spawn(uint8_t player_id) const {
|
|
const SDL_FRect& zona = Defaults::Zones::PLAYAREA;
|
|
|
|
float x_ratio;
|
|
if (match_config_.es_un_jugador()) {
|
|
// Un sol player: spawn al centro (50%)
|
|
x_ratio = 0.5F;
|
|
} else {
|
|
// Dos jugadors: spawn a posicions separades
|
|
x_ratio = (player_id == 0)
|
|
? Defaults::Game::P1_SPAWN_X_RATIO // 33%
|
|
: Defaults::Game::P2_SPAWN_X_RATIO; // 67%
|
|
}
|
|
|
|
return {
|
|
.x = zona.x + (zona.w * x_ratio),
|
|
.y = zona.y + (zona.h * Defaults::Game::SPAWN_Y_RATIO)};
|
|
}
|
|
|
|
void GameScene::disparar_bala(uint8_t player_id) {
|
|
// Verificar que el player está vivo
|
|
if (hit_timer_per_player_[player_id] > 0.0F) {
|
|
return;
|
|
}
|
|
if (!ships_[player_id].isAlive()) {
|
|
return;
|
|
}
|
|
|
|
// Calcular posición en la punta de la nave
|
|
const Vec2& ship_centre = ships_[player_id].getCenter();
|
|
float ship_angle = ships_[player_id].getAngle();
|
|
|
|
constexpr float LOCAL_TIP_X = 0.0F;
|
|
constexpr float LOCAL_TIP_Y = -12.0F;
|
|
float cos_a = std::cos(ship_angle);
|
|
float sin_a = std::sin(ship_angle);
|
|
float tip_x = (LOCAL_TIP_X * cos_a) - (LOCAL_TIP_Y * sin_a) + ship_centre.x;
|
|
float tip_y = (LOCAL_TIP_X * sin_a) + (LOCAL_TIP_Y * cos_a) + ship_centre.y;
|
|
Vec2 posicio_dispar = {.x = tip_x, .y = tip_y};
|
|
|
|
// Buscar primera bullet inactiva en el pool del player
|
|
int start_idx = player_id * 3; // P1=[0,1,2], P2=[3,4,5]
|
|
for (int i = start_idx; i < start_idx + 3; i++) {
|
|
if (!bullets_[i].esta_activa()) {
|
|
bullets_[i].disparar(posicio_dispar, ship_angle, player_id);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void GameScene::dibuixar_continue() {
|
|
const SDL_FRect& play_area = Defaults::Zones::PLAYAREA;
|
|
constexpr float spacing = 4.0F;
|
|
|
|
// "CONTINUE" text (using constants)
|
|
const std::string continue_text = "CONTINUE";
|
|
float escala_continue = Defaults::Game::ContinueScreen::CONTINUE_TEXT_SCALE;
|
|
float y_ratio_continue = Defaults::Game::ContinueScreen::CONTINUE_TEXT_Y_RATIO;
|
|
|
|
float centre_x = play_area.x + (play_area.w / 2.0F);
|
|
float centre_y_continue = play_area.y + (play_area.h * y_ratio_continue);
|
|
|
|
text_.renderCentered(continue_text, {.x = centre_x, .y = centre_y_continue}, escala_continue, spacing);
|
|
|
|
// Countdown number (using constants)
|
|
const std::string counter_str = std::to_string(continue_counter_);
|
|
float escala_counter = Defaults::Game::ContinueScreen::COUNTER_TEXT_SCALE;
|
|
float y_ratio_counter = Defaults::Game::ContinueScreen::COUNTER_TEXT_Y_RATIO;
|
|
|
|
float centre_y_counter = play_area.y + (play_area.h * y_ratio_counter);
|
|
|
|
text_.renderCentered(counter_str, {.x = centre_x, .y = centre_y_counter}, escala_counter, spacing);
|
|
|
|
// "CONTINUES LEFT" (conditional + using constants)
|
|
if (!Defaults::Game::INFINITE_CONTINUES) {
|
|
const std::string continues_text = "CONTINUES LEFT: " + std::to_string(Defaults::Game::MAX_CONTINUES - continues_used_);
|
|
float escala_info = Defaults::Game::ContinueScreen::INFO_TEXT_SCALE;
|
|
float y_ratio_info = Defaults::Game::ContinueScreen::INFO_TEXT_Y_RATIO;
|
|
|
|
float centre_y_info = play_area.y + (play_area.h * y_ratio_info);
|
|
|
|
text_.renderCentered(continues_text, {.x = centre_x, .y = centre_y_info}, escala_info, spacing);
|
|
}
|
|
}
|
|
|
|
void GameScene::unir_jugador(uint8_t player_id) {
|
|
// Activate player
|
|
if (player_id == 0) {
|
|
match_config_.jugador1_actiu = true;
|
|
} else {
|
|
match_config_.jugador2_actiu = true;
|
|
}
|
|
|
|
// Reset stats
|
|
lives_per_player_[player_id] = Defaults::Game::STARTING_LIVES;
|
|
score_per_player_[player_id] = 0;
|
|
hit_timer_per_player_[player_id] = 0.0F;
|
|
|
|
// Spawn with invulnerability
|
|
Vec2 spawn_pos = obtenir_punt_spawn(player_id);
|
|
ships_[player_id].init(&spawn_pos, true);
|
|
|
|
// No visual message, just spawn (per user requirement)
|
|
|
|
std::cout << "[GameScene] Jugador " << (int)(player_id + 1) << " s'ha unit a la match!" << '\n';
|
|
}
|