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>
108 lines
4.6 KiB
C++
108 lines
4.6 KiB
C++
// game_scene.hpp - Lógica principal del juego
|
|
// © 1999 Visente i Sergi (versión Pascal)
|
|
// © 2025 Port a C++20 con SDL3
|
|
|
|
#pragma once
|
|
|
|
#include <array>
|
|
#include <cstdint>
|
|
#include <memory>
|
|
#include <string>
|
|
|
|
#include "core/graphics/vector_text.hpp"
|
|
#include "core/physics/physics_world.hpp"
|
|
#include "core/rendering/sdl_manager.hpp"
|
|
#include "core/system/scene_context.hpp"
|
|
#include "core/system/game_config.hpp"
|
|
#include "core/types.hpp"
|
|
#include "game/constants.hpp"
|
|
#include "game/effects/debris_manager.hpp"
|
|
#include "game/effects/floating_score_manager.hpp"
|
|
#include "game/entities/bullet.hpp"
|
|
#include "game/entities/enemy.hpp"
|
|
#include "game/entities/ship.hpp"
|
|
#include "game/stage_system/stage_config.hpp"
|
|
#include "game/stage_system/stage_manager.hpp"
|
|
|
|
// Game over state machine
|
|
enum class GameOverState : uint8_t {
|
|
NONE, // Normal gameplay
|
|
CONTINUE, // Continue countdown screen (9→0)
|
|
GAME_OVER // Final game over (returning to title)
|
|
};
|
|
|
|
// Clase principal del juego (escena)
|
|
class GameScene {
|
|
public:
|
|
explicit GameScene(SDLManager& sdl, SceneManager::SceneContext& context);
|
|
~GameScene() = default;
|
|
|
|
void run(); // Bucle principal de l'escena
|
|
void init();
|
|
void update(float delta_time);
|
|
void draw();
|
|
|
|
private:
|
|
SDLManager& sdl_;
|
|
SceneManager::SceneContext& context_;
|
|
GameConfig::MatchConfig match_config_; // Configuración de jugadors active
|
|
|
|
// Mundo físico (Fase 5) — integración cinemática + colisiones
|
|
Physics::PhysicsWorld physics_world_;
|
|
|
|
// Efectes visuals
|
|
Effects::DebrisManager debris_manager_;
|
|
Effects::FloatingScoreManager floating_score_manager_;
|
|
|
|
// Estat del juego
|
|
std::array<Ship, 2> ships_; // [0]=P1, [1]=P2
|
|
std::array<Enemy, Constants::MAX_ORNIS> enemies_;
|
|
std::array<Bullet, Constants::MAX_BALES * 2> bullets_; // 6 balas: P1=[0,1,2], P2=[3,4,5]
|
|
std::array<float, 2> hit_timer_per_player_; // Death timers per player (seconds)
|
|
|
|
// Lives and game over system
|
|
std::array<int, 2> lives_per_player_; // [0]=P1, [1]=P2
|
|
GameOverState game_over_state_; // Game over state machine (NONE, CONTINUE, GAME_OVER)
|
|
int continue_counter_; // Continue countdown (9→0)
|
|
float continue_tick_timer_; // Timer for countdown tick (1.0s)
|
|
int continues_used_; // Continues used this game (0-3 max)
|
|
float game_over_timer_; // Final GAME OVER timer before title screen
|
|
Vec2 death_position_; // Death position (for respawn)
|
|
std::array<int, 2> score_per_player_; // [0]=P1, [1]=P2
|
|
|
|
// Text vectorial
|
|
Graphics::VectorText text_;
|
|
|
|
// [NEW] Stage system
|
|
std::unique_ptr<StageSystem::StageSystemConfig> stage_config_;
|
|
std::unique_ptr<StageSystem::StageManager> stage_manager_;
|
|
|
|
// Control de sons de animación INIT_HUD
|
|
bool init_hud_rect_sound_played_; // Flag para evitar repetir sonido del rectángulo
|
|
|
|
// Funciones privades
|
|
void tocado(uint8_t player_id);
|
|
void dibuixar_marges() const; // Dibuixar vores de la zona de juego
|
|
void dibuixar_marcador(); // Dibuixar marcador de puntuación
|
|
void disparar_bala(uint8_t player_id); // Shoot bullet from player
|
|
[[nodiscard]] Vec2 obtenir_punt_spawn(uint8_t player_id) const; // Get spawn position for player
|
|
|
|
// [NEW] Continue & Join system
|
|
void unir_jugador(uint8_t player_id); // Join inactive player mid-game
|
|
void dibuixar_continue(); // Draw continue screen
|
|
|
|
// [NEW] Stage system helpers
|
|
void dibuixar_missatge_stage(const std::string& message);
|
|
|
|
// [NEW] Funciones de animación per INIT_HUD
|
|
void dibuixar_marges_animat(float progress) const; // Rectangle con creixement uniforme
|
|
void dibuixar_marcador_animat(float progress); // Marcador que puja desde baix
|
|
[[nodiscard]] Vec2 calcular_posicio_nau_init_hud(float progress, uint8_t player_id) const; // Posición animada de la ship
|
|
|
|
// [NEW] Función helper del sistema de animación INIT_HUD
|
|
[[nodiscard]] float calcular_progress_rango(float global_progress, float ratio_init, float ratio_end) const;
|
|
|
|
// [NEW] Función helper del marcador
|
|
[[nodiscard]] std::string buildScoreboard() const;
|
|
};
|