jailers/jaildoctors_dilemma
5
0
Fork 0
forked from jaildesigner-jailgames/jaildoctors_dilemma
Code Pull Requests Activity

treballant en les novetats de LoadingScreen

Browse Source
This commit is contained in:
Sergio
2025-10-26 21:44:16 +01:00
parent 96506988b6
commit 0c87612a17
4 changed files with 211 additions and 117 deletions
Download Patch File Download Diff File Expand all files Collapse all files

198
source/game/scenes/loading_screen.cpp
View File

@@ -3,12 +3,12 @@
#include <SDL3/SDL.h>
#include <stdlib.h> // Para rand
#include "core/audio/audio.hpp" // Para Audio
#include "core/input/global_inputs.hpp" // Para check
#include "core/rendering/screen.hpp" // Para Screen
#include "core/rendering/surface.hpp" // Para Surface
#include "core/rendering/surface_sprite.hpp" // Para SSprite
#include "core/resources/resource.hpp" // Para Resource
#include "external/jail_audio.h" // Para JA_PlayMusic, JA_SetVolume, JA_StopMusic
#include "game/options.hpp" // Para Options, options, SectionState, Options...
#include "game/scene_manager.hpp" // Para SceneManager
#include "utils/defines.hpp" // Para GAME_SPEED
@@ -23,8 +23,9 @@ LoadingScreen::LoadingScreen()
color_loading_screen_sprite_(std::make_shared<SurfaceSprite>(color_loading_screen_surface_, 0, 0, color_loading_screen_surface_->getWidth(), color_loading_screen_surface_->getHeight())),
screen_surface_(std::make_shared<Surface>(Options::game.width, Options::game.height)),
delta_timer_(std::make_unique<DeltaTimer>()),
state_(LoadingState::PRE_LOADING),
state_(LoadingState::SILENT1),
state_time_(0.0f),
current_border_type_(BorderType::NONE),
load_rect_{0, 0, 0, 1.0f} {
// Configura la superficie donde se van a pintar los sprites
screen_surface_->clear(static_cast<Uint8>(PaletteColor::WHITE));
@@ -37,12 +38,13 @@ LoadingScreen::LoadingScreen()
initLineIndexArray();
// Cambia el color del borde
Screen::get()->setBorderColor(stringToColor("black"));
Screen::get()->setBorderColor(stringToColor("white"));
transitionToState(LoadingState::SILENT1);
}
// Destructor
LoadingScreen::~LoadingScreen() {
JA_StopMusic();
Audio::get()->stopMusic();
}
// Comprueba el manejador de eventos
@@ -78,25 +80,39 @@ void LoadingScreen::transitionToState(LoadingState new_state) {
// Acciones específicas al entrar en cada estado
switch (new_state) {
case LoadingState::PRE_LOADING:
// No hay acción específica
case LoadingState::SILENT1:
case LoadingState::SILENT2:
current_border_type_ = BorderType::WHITE;
Audio::get()->stopMusic();
break;
case LoadingState::HEADER1:
case LoadingState::HEADER2:
current_border_type_ = BorderType::RED;
// Reproducir sonido de cargar el header
Audio::get()->playMusic("loading_sound1.ogg");
break;
case LoadingState::BYTES1:
case LoadingState::BYTES2:
case LoadingState::LOADING_MONO:
current_border_type_ = BorderType::YELLOW;
// Reproducir sonido de carga monocromática
JA_PlayMusic(Resource::get()->getMusic("loading_sound2.ogg"));
Audio::get()->playMusic("loading_sound2.ogg");
break;
case LoadingState::LOADING_COLOR:
current_border_type_ = BorderType::YELLOW;
// Reproducir sonido de carga en color
JA_PlayMusic(Resource::get()->getMusic("loading_sound3.ogg"));
Audio::get()->playMusic("loading_sound3.ogg");
break;
case LoadingState::COMPLETE:
current_border_type_ = BorderType::WHITE;
// Transicionar a la pantalla de título
SceneManager::current = SceneManager::Scene::TITLE;
SceneManager::options = SceneManager::Options::TITLE_WITH_LOADING_SCREEN;
JA_StopMusic();
Audio::get()->stopMusic();
break;
}
}
@@ -105,12 +121,50 @@ void LoadingScreen::transitionToState(LoadingState new_state) {
void LoadingScreen::updateState(float delta_time) {
state_time_ += delta_time;
// Solo PRE_LOADING transiciona por tiempo
// LOADING_MONO y LOADING_COLOR transicionan cuando completan su progreso
if (state_ == LoadingState::PRE_LOADING) {
if (state_time_ >= PRE_LOADING_DURATION) {
transitionToState(LoadingState::LOADING_MONO);
}
// Transiciones automáticas por tiempo para los estados iniciales
// LOADING_MONO y LOADING_COLOR transicionan en sus propias funciones
switch (state_) {
case LoadingState::SILENT1:
if (state_time_ >= SILENT1_DURATION) {
transitionToState(LoadingState::HEADER1);
}
break;
case LoadingState::HEADER1:
if (state_time_ >= HEADER1_DURATION) {
transitionToState(LoadingState::BYTES1);
}
break;
case LoadingState::BYTES1:
if (state_time_ >= BYTES1_DURATION) {
transitionToState(LoadingState::SILENT2);
}
break;
case LoadingState::SILENT2:
if (state_time_ >= SILENT2_DURATION) {
transitionToState(LoadingState::HEADER2);
}
break;
case LoadingState::HEADER2:
if (state_time_ >= HEADER2_DURATION) {
transitionToState(LoadingState::LOADING_MONO);
}
break;
case LoadingState::BYTES2:
if (state_time_ >= BYTES2_DURATION) {
transitionToState(LoadingState::COMPLETE);
}
break;
case LoadingState::LOADING_MONO:
case LoadingState::LOADING_COLOR:
case LoadingState::COMPLETE:
// Estos estados se gestionan en updateMonoLoad/updateColorLoad
break;
}
}
@@ -154,7 +208,7 @@ void LoadingScreen::updateMonoLoad(float delta_time) {
Screen::get()->setRendererSurface(previous_renderer);
}
// Gestiona la carga en color (time-based simplificado)
// Gestiona la carga en color
void LoadingScreen::updateColorLoad(float delta_time) {
// Calcular progreso lineal (0.0 - 1.0)
float progress = state_time_ / LOADING_COLOR_DURATION;
@@ -169,7 +223,7 @@ void LoadingScreen::updateColorLoad(float delta_time) {
// Verificar si ha completado todos los bloques
if (current_block >= COLOR_TOTAL_BLOCKS) {
transitionToState(LoadingState::COMPLETE);
transitionToState(LoadingState::BYTES2);
return;
}
@@ -189,14 +243,8 @@ void LoadingScreen::updateColorLoad(float delta_time) {
Screen::get()->setRendererSurface(previous_renderer);
}
// Dibuja la pantalla de carga
void LoadingScreen::renderLoad() {
// El dibujo incremental ya se realiza en updateMonoLoad() y updateColorLoad()
// Esta función ya no es necesaria, pero se mantiene por compatibilidad
}
// Dibuja el efecto de carga en el borde
void LoadingScreen::renderBorder() {
// Dibuja el efecto de carga amarillo y azul en el borde
void LoadingScreen::renderYellowBorder() {
// Obtiene la Surface del borde
auto border = Screen::get()->getBorderSurface();
@@ -222,18 +270,71 @@ void LoadingScreen::renderBorder() {
}
}
// Dibuja el efecto de carga rojo y azul en el borde
void LoadingScreen::renderRedBorder() {
// Obtiene la Surface del borde
auto border = Screen::get()->getBorderSurface();
// Pinta el borde de color azul
border->clear(static_cast<Uint8>(PaletteColor::CYAN));
// Añade lineas rojas
const Uint8 COLOR = static_cast<Uint8>(PaletteColor::RED);
const int WIDTH = Options::game.width + (Options::video.border.width * 2);
const int HEIGHT = Options::game.height + (Options::video.border.height * 2);
bool draw_enabled = true;
// Primera linea (para que tenga poca variacion)
int row = 0;
const int FIRST_ROW_HEIGHT = (rand() % 4) + 3;
if (draw_enabled) {
for (int i = row; i < row + FIRST_ROW_HEIGHT; ++i) {
border->drawLine(0, i, WIDTH, i, COLOR);
}
}
row += FIRST_ROW_HEIGHT;
draw_enabled = !draw_enabled;
// Resto de lineas
while (row < HEIGHT) {
const int ROW_HEIGHT = (rand() % 3) + 8;
if (draw_enabled) {
for (int i = row; i < row + ROW_HEIGHT; ++i) {
border->drawLine(0, i, WIDTH, i, COLOR);
}
}
row += ROW_HEIGHT;
draw_enabled = !draw_enabled;
}
}
// Dibuja el borde de color blanco
void LoadingScreen::renderWhiteBorder() {
// Obtiene la Surface del borde
auto border = Screen::get()->getBorderSurface();
// Pinta el borde de color azul
border->clear(static_cast<Uint8>(PaletteColor::WHITE));
}
// Actualiza las variables
void LoadingScreen::update() {
// Obtener delta time desde el último frame
const float delta_time = delta_timer_->tick();
checkInput(); // Comprueba las entradas
updateState(delta_time); // Actualiza el estado y gestiona transiciones
checkInput(); // Comprueba las entradas
updateState(delta_time); // Actualiza el estado y gestiona transiciones
// Actualizar la carga según el estado actual
switch (state_) {
case LoadingState::PRE_LOADING:
// No hay animación de carga durante la pausa inicial
case LoadingState::SILENT1:
case LoadingState::HEADER1:
case LoadingState::BYTES1:
case LoadingState::SILENT2:
case LoadingState::HEADER2:
case LoadingState::BYTES2:
// Por ahora no hacen nada específico
// Tú definirás la lógica de cada estado aquí
break;
case LoadingState::LOADING_MONO:
@@ -249,16 +350,15 @@ void LoadingScreen::update() {
break;
}
renderLoad(); // Dibuja la pantalla de carga
Screen::get()->update(); // Actualiza el objeto Screen
// Singletones
Audio::get()->update(); // Actualiza el objeto Audio
Screen::get()->update(); // Actualiza el objeto Screen
}
// Dibuja en pantalla
void LoadingScreen::render() {
if (Options::video.border.enabled) {
// Dibuja el efecto de carga en el borde
renderBorder();
}
// Pinta el borde
renderBorder();
// Prepara para empezar a dibujar en la textura de juego
Screen::get()->start();
@@ -273,9 +373,8 @@ void LoadingScreen::render() {
// Bucle para el logo del juego
void LoadingScreen::run() {
// Inicia el sonido de carga
JA_SetVolume(64);
JA_PlayMusic(Resource::get()->getMusic("loading_sound1.ogg"));
// Ajusta el volumen
Audio::get()->setMusicVolume(50);
// Limpia la pantalla
Screen::get()->start();
@@ -288,5 +387,26 @@ void LoadingScreen::run() {
render();
}
JA_SetVolume(128);
Audio::get()->setMusicVolume(100);
}
// Pinta el borde
void LoadingScreen::renderBorder() {
if (Options::video.border.enabled) {
// Dibuja el efecto de carga en el borde según el tipo actual
switch (current_border_type_) {
case BorderType::YELLOW:
renderYellowBorder();
break;
case BorderType::RED:
renderRedBorder();
break;
case BorderType::WHITE:
renderWhiteBorder();
break;
case BorderType::NONE:
// No renderizar borde
break;
}
}
}