jaildesigner-jailgames/jaildoctors_dilemma
1
0
Fork 2
Code Issues 1 Pull Requests Projects Releases 20 Wiki Activity

migrat Ending a time based

Browse Source
This commit is contained in:
Sergio
2025-10-30 22:57:43 +01:00
parent 99893a0c83
commit 3680ff3935
3 changed files with 256 additions and 104 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
source/game/scene_manager.hpp
View File

@@ -34,7 +34,7 @@ enum class Options {
// --- Variables de estado globales --- // --- Variables de estado globales ---
#ifdef _DEBUG #ifdef _DEBUG
inline Scene current = Scene::CREDITS; // Escena actual inline Scene current = Scene::ENDING; // Escena actual
inline Options options = Options::LOGO_TO_LOADING_SCREEN; // Opciones de la escena actual inline Options options = Options::LOGO_TO_LOADING_SCREEN; // Opciones de la escena actual
#else #else
inline Scene current = Scene::LOGO; // Escena actual inline Scene current = Scene::LOGO; // Escena actual

294
source/game/scenes/ending.cpp
View File

@@ -10,20 +10,17 @@
#include "core/rendering/surface_sprite.hpp" // Para SSprite #include "core/rendering/surface_sprite.hpp" // Para SSprite
#include "core/rendering/text.hpp" // Para Text, TEXT_STROKE #include "core/rendering/text.hpp" // Para Text, TEXT_STROKE
#include "core/resources/resource.hpp" // Para Resource #include "core/resources/resource.hpp" // Para Resource
#include "core/system/global_events.hpp" // Para check
#include "external/jail_audio.h" // Para JA_SetVolume, JA_PlayMusic, JA_StopMusic #include "external/jail_audio.h" // Para JA_SetVolume, JA_PlayMusic, JA_StopMusic
#include "game/options.hpp" // Para Options, options, OptionsGame, SectionS... #include "game/options.hpp" // Para Options, options, OptionsGame, SectionS...
#include "game/scene_manager.hpp" // Para SceneManager #include "game/scene_manager.hpp" // Para SceneManager
#include "utils/defines.hpp" // Para GAME_SPEED #include "utils/defines.hpp" // Para GAME_SPEED
#include "core/system/global_events.hpp" // Para check #include "utils/delta_timer.hpp" // Para DeltaTimer
#include "utils/utils.hpp" // Para PaletteColor #include "utils/utils.hpp" // Para PaletteColor
// Constructor // Constructor
Ending::Ending() Ending::Ending()
: counter_(-1), : delta_timer_(std::make_unique<DeltaTimer>()) {
pre_counter_(0),
cover_counter_(0),
ticks_(0),
current_scene_(0) {
SceneManager::current = SceneManager::Scene::ENDING; SceneManager::current = SceneManager::Scene::ENDING;
SceneManager::options = SceneManager::Options::NONE; SceneManager::options = SceneManager::Options::NONE;
@@ -48,29 +45,26 @@ Ending::Ending()
// Actualiza el objeto // Actualiza el objeto
void Ending::update() { void Ending::update() {
// Comprueba que la diferencia de ticks sea mayor a la velocidad del juego // Obtiene el delta time
if (SDL_GetTicks() - ticks_ > GAME_SPEED) { current_delta_ = delta_timer_->tick();
// Actualiza el contador de ticks
ticks_ = SDL_GetTicks();
// Comprueba las entradas // Comprueba las entradas
checkInput(); checkInput();
// Actualiza el contador // Actualiza el tiempo total
updateCounters(); total_time_ += current_delta_;
// Actualiza las cortinillas de los elementos // Actualiza la máquina de estados
updateSpriteCovers(); updateState(current_delta_);
// Comprueba si se ha de cambiar de escena // Actualiza las cortinillas de los elementos
checkChangeScene(); updateSpriteCovers();
// Actualiza el volumen de la musica // Actualiza el volumen de la musica
updateMusicVolume(); updateMusicVolume();
// Actualiza el objeto Screen // Actualiza el objeto Screen
Screen::get()->update(); Screen::get()->update(current_delta_);
}
} }
// Dibuja el final en pantalla // Dibuja el final en pantalla
@@ -81,20 +75,26 @@ void Ending::render() {
// Limpia la pantalla // Limpia la pantalla
Screen::get()->clearSurface(static_cast<Uint8>(PaletteColor::BLACK)); Screen::get()->clearSurface(static_cast<Uint8>(PaletteColor::BLACK));
// Dibuja las imagenes de la escena // Skip rendering durante WARMING_UP
sprite_pics_.at(current_scene_).image_sprite->render(); if (state_ != State::WARMING_UP) {
sprite_pics_.at(current_scene_).cover_sprite->render(); // Dibuja las imagenes de la escena
sprite_pics_.at(current_scene_).image_sprite->render();
sprite_pics_.at(current_scene_).cover_sprite->render();
// Dibuja los textos de la escena // Dibuja los textos de la escena
for (const auto& ti : scenes_.at(current_scene_).text_index) { for (const auto& ti : scenes_.at(current_scene_).text_index) {
if (counter_ > ti.trigger) { // Convertir trigger de frames a segundos @ 60fps
sprite_texts_.at(ti.index).image_sprite->render(); const float TRIGGER_TIME = static_cast<float>(ti.trigger) / 60.0F;
sprite_texts_.at(ti.index).cover_sprite->render();
if (state_time_ > TRIGGER_TIME) {
sprite_texts_.at(ti.index).image_sprite->render();
sprite_texts_.at(ti.index).cover_sprite->render();
}
} }
}
// Dibuja la cortinilla de cambio de escena // Dibuja la cortinilla de cambio de escena
renderCoverTexture(); renderCoverTexture();
}
// Vuelca el contenido del renderizador en pantalla // Vuelca el contenido del renderizador en pantalla
Screen::get()->render(); Screen::get()->render();
@@ -113,6 +113,71 @@ void Ending::checkInput() {
GlobalInputs::check(); GlobalInputs::check();
} }
// Transición entre estados
void Ending::transitionToState(State new_state) {
state_ = new_state;
state_time_ = 0.0F;
// Al cambiar a una escena, resetear fadeout_time_
if (new_state != State::WARMING_UP && new_state != State::ENDING) {
fadeout_time_ = 0.0F;
}
}
// Actualiza la máquina de estados
void Ending::updateState(float delta_time) {
state_time_ += delta_time;
switch (state_) {
case State::WARMING_UP:
if (state_time_ >= WARMUP_DURATION) {
transitionToState(State::SCENE_0);
current_scene_ = 0;
}
break;
case State::SCENE_0:
checkChangeScene();
// Actualizar fadeout_time_ si estamos cerca del final
if (state_time_ >= SCENE_0_DURATION - FADEOUT_START_OFFSET) {
fadeout_time_ += delta_time;
}
break;
case State::SCENE_1:
checkChangeScene();
if (state_time_ >= SCENE_1_DURATION - FADEOUT_START_OFFSET) {
fadeout_time_ += delta_time;
}
break;
case State::SCENE_2:
checkChangeScene();
if (state_time_ >= SCENE_2_DURATION - FADEOUT_START_OFFSET) {
fadeout_time_ += delta_time;
}
break;
case State::SCENE_3:
checkChangeScene();
if (state_time_ >= SCENE_3_DURATION - FADEOUT_START_OFFSET) {
fadeout_time_ += delta_time;
}
break;
case State::SCENE_4:
checkChangeScene();
if (state_time_ >= SCENE_4_DURATION - FADEOUT_START_OFFSET) {
fadeout_time_ += delta_time;
}
break;
case State::ENDING:
// Transición a ENDING2
break;
}
}
// Inicializa los textos // Inicializa los textos
void Ending::iniTexts() { void Ending::iniTexts() {
// Vector con los textos // Vector con los textos
@@ -370,63 +435,119 @@ void Ending::run() {
JA_SetVolume(128); JA_SetVolume(128);
} }
// Actualiza los contadores
void Ending::updateCounters() {
// Incrementa el contador
if (pre_counter_ < 200) {
pre_counter_++;
} else {
counter_++;
}
if (counter_ > scenes_[current_scene_].counter_end - 100) {
cover_counter_++;
}
}
// Actualiza las cortinillas de los elementos // Actualiza las cortinillas de los elementos
void Ending::updateSpriteCovers() { void Ending::updateSpriteCovers() {
// Skip durante WARMING_UP
if (state_ == State::WARMING_UP) {
return;
}
// Actualiza la cortinilla de los textos // Actualiza la cortinilla de los textos
if (counter_ % 4 == 0) { for (const auto& ti : scenes_.at(current_scene_).text_index) {
for (auto ti : scenes_.at(current_scene_).text_index) { // Convertir trigger de frames a segundos @ 60fps
if (counter_ > ti.trigger) { const float TRIGGER_TIME = static_cast<float>(ti.trigger) / 60.0F;
if (sprite_texts_.at(ti.index).cover_clip_desp > 0) {
sprite_texts_.at(ti.index).cover_clip_desp -= 2; if (state_time_ > TRIGGER_TIME) {
} else if (sprite_texts_.at(ti.index).cover_clip_height > 0) { // Tiempo transcurrido desde que se activó el trigger
sprite_texts_.at(ti.index).cover_clip_height -= 2; const float TIME_SINCE_TRIGGER = state_time_ - TRIGGER_TIME;
sprite_texts_.at(ti.index).cover_sprite->setY(sprite_texts_.at(ti.index).cover_sprite->getY() + 2);
} // Píxeles revelados: tiempo * velocidad
sprite_texts_.at(ti.index).cover_sprite->setClip(0, sprite_texts_.at(ti.index).cover_clip_desp, sprite_texts_.at(ti.index).cover_sprite->getWidth(), sprite_texts_.at(ti.index).cover_clip_height); const float PIXELS_REVEALED = TIME_SINCE_TRIGGER * TEXT_REVEAL_SPEED;
// Obtener altura inicial de la superficie
const float INITIAL_HEIGHT = sprite_texts_.at(ti.index).image_surface->getHeight();
const float Y_INITIAL = sprite_texts_.at(ti.index).image_sprite->getY();
// Fase 1: Revelar malla decorativa (8 píxeles)
if (PIXELS_REVEALED < 8.0F) {
sprite_texts_.at(ti.index).cover_clip_desp = static_cast<int>(8.0F - PIXELS_REVEALED);
sprite_texts_.at(ti.index).cover_clip_height = static_cast<int>(INITIAL_HEIGHT);
sprite_texts_.at(ti.index).cover_sprite->setY(Y_INITIAL);
} }
// Fase 2: Revelar contenido
else {
sprite_texts_.at(ti.index).cover_clip_desp = 0;
const float CONTENT_PIXELS = PIXELS_REVEALED - 8.0F;
sprite_texts_.at(ti.index).cover_clip_height = std::max(0, static_cast<int>(INITIAL_HEIGHT - CONTENT_PIXELS));
sprite_texts_.at(ti.index).cover_sprite->setY(Y_INITIAL + static_cast<int>(CONTENT_PIXELS));
}
sprite_texts_.at(ti.index).cover_sprite->setClip(
0,
sprite_texts_.at(ti.index).cover_clip_desp,
sprite_texts_.at(ti.index).cover_sprite->getWidth(),
sprite_texts_.at(ti.index).cover_clip_height
);
} }
} }
// Actualiza la cortinilla de las imágenes // Actualiza la cortinilla de las imágenes (revelación continua desde el inicio de la escena)
if (counter_ % 2 == 0) { const float PIXELS_REVEALED = state_time_ * IMAGE_REVEAL_SPEED;
if (sprite_pics_.at(current_scene_).cover_clip_desp > 0) { const float INITIAL_HEIGHT = sprite_pics_.at(current_scene_).image_surface->getHeight();
sprite_pics_.at(current_scene_).cover_clip_desp -= 2; const float Y_INITIAL = sprite_pics_.at(current_scene_).image_sprite->getY();
} else if (sprite_pics_.at(current_scene_).cover_clip_height > 0) {
sprite_pics_.at(current_scene_).cover_clip_height -= 2; // Fase 1: Revelar malla decorativa (8 píxeles)
sprite_pics_.at(current_scene_).cover_clip_height = std::max(sprite_pics_.at(current_scene_).cover_clip_height, 0); if (PIXELS_REVEALED < 8.0F) {
sprite_pics_.at(current_scene_).cover_sprite->setY(sprite_pics_.at(current_scene_).cover_sprite->getY() + 2); sprite_pics_.at(current_scene_).cover_clip_desp = static_cast<int>(8.0F - PIXELS_REVEALED);
} sprite_pics_.at(current_scene_).cover_clip_height = static_cast<int>(INITIAL_HEIGHT);
sprite_pics_.at(current_scene_).cover_sprite->setClip(0, sprite_pics_.at(current_scene_).cover_clip_desp, sprite_pics_.at(current_scene_).cover_sprite->getWidth(), sprite_pics_.at(current_scene_).cover_clip_height); sprite_pics_.at(current_scene_).cover_sprite->setY(Y_INITIAL);
} }
// Fase 2: Revelar contenido
else {
sprite_pics_.at(current_scene_).cover_clip_desp = 0;
const float CONTENT_PIXELS = PIXELS_REVEALED - 8.0F;
sprite_pics_.at(current_scene_).cover_clip_height = std::max(0, static_cast<int>(INITIAL_HEIGHT - CONTENT_PIXELS));
sprite_pics_.at(current_scene_).cover_sprite->setY(Y_INITIAL + static_cast<int>(CONTENT_PIXELS));
}
sprite_pics_.at(current_scene_).cover_sprite->setClip(
0,
sprite_pics_.at(current_scene_).cover_clip_desp,
sprite_pics_.at(current_scene_).cover_sprite->getWidth(),
sprite_pics_.at(current_scene_).cover_clip_height
);
} }
// Comprueba si se ha de cambiar de escena // Comprueba si se ha de cambiar de escena
void Ending::checkChangeScene() { void Ending::checkChangeScene() {
if (counter_ > scenes_[current_scene_].counter_end) { // Obtener duración de la escena actual
current_scene_++; float CURRENT_DURATION = 0.0F;
counter_ = 0; State NEXT_STATE = State::ENDING;
cover_counter_ = 0;
if (current_scene_ == 5) { switch (state_) {
case State::SCENE_0:
CURRENT_DURATION = SCENE_0_DURATION;
NEXT_STATE = State::SCENE_1;
break;
case State::SCENE_1:
CURRENT_DURATION = SCENE_1_DURATION;
NEXT_STATE = State::SCENE_2;
break;
case State::SCENE_2:
CURRENT_DURATION = SCENE_2_DURATION;
NEXT_STATE = State::SCENE_3;
break;
case State::SCENE_3:
CURRENT_DURATION = SCENE_3_DURATION;
NEXT_STATE = State::SCENE_4;
break;
case State::SCENE_4:
CURRENT_DURATION = SCENE_4_DURATION;
NEXT_STATE = State::ENDING;
break;
default:
return;
}
// Comprobar si ha pasado la duración de la escena
if (state_time_ >= CURRENT_DURATION) {
if (NEXT_STATE == State::ENDING) {
// Termina el bucle // Termina el bucle
SceneManager::current = SceneManager::Scene::ENDING2; SceneManager::current = SceneManager::Scene::ENDING2;
} else {
// Mantiene los valores anteriores // Transición a la siguiente escena
current_scene_ = 4; current_scene_++;
cover_counter_ = 100; transitionToState(NEXT_STATE);
} }
} }
} }
@@ -460,20 +581,23 @@ void Ending::fillCoverTexture() {
// Dibuja la cortinilla de cambio de escena // Dibuja la cortinilla de cambio de escena
void Ending::renderCoverTexture() { void Ending::renderCoverTexture() {
if (cover_counter_ > 0) { if (fadeout_time_ > 0.0F) {
// Dibuja la textura que cubre el texto // Convertir fadeout_time_ a equivalente de cover_counter_ @ 60fps
const int OFFSET = std::min(cover_counter_, 100); const float FADEOUT_COUNTER = std::min(fadeout_time_ * 60.0F, 100.0F);
SDL_FRect src_rect = {0.0F, 200.0F - (cover_counter_ * 2.0F), 256.0F, OFFSET * 2.0F};
SDL_FRect dst_rect = {0.0F, 0.0F, 256.0F, OFFSET * 2.0F}; SDL_FRect src_rect = {0.0F, 200.0F - (FADEOUT_COUNTER * 2.0F), 256.0F, FADEOUT_COUNTER * 2.0F};
SDL_FRect dst_rect = {0.0F, 0.0F, 256.0F, FADEOUT_COUNTER * 2.0F};
cover_surface_->render(&src_rect, &dst_rect); cover_surface_->render(&src_rect, &dst_rect);
} }
} }
// Actualiza el volumen de la musica // Actualiza el volumen de la musica
void Ending::updateMusicVolume() const { void Ending::updateMusicVolume() const {
if (current_scene_ == 4 && cover_counter_ > 0) { if (state_ == State::SCENE_4 && fadeout_time_ > 0.0F) {
const float STEP = (100.0F - cover_counter_) / 100.0F; // Convertir fadeout_time_ a equivalente de cover_counter_ @ 60fps
const int VOLUME = 128 * STEP; const float FADEOUT_COUNTER = std::min(fadeout_time_ * 60.0F, 100.0F);
const float STEP = (100.0F - FADEOUT_COUNTER) / 100.0F;
const int VOLUME = static_cast<int>(128.0F * STEP);
JA_SetVolume(VOLUME); JA_SetVolume(VOLUME);
} }
} }

64
source/game/scenes/ending.hpp
View File

@@ -7,6 +7,7 @@
#include <vector> // Para vector #include <vector> // Para vector
class SurfaceSprite; // lines 8-8 class SurfaceSprite; // lines 8-8
class Surface; // lines 9-9 class Surface; // lines 9-9
class DeltaTimer;
class Ending { class Ending {
public: public:
@@ -18,6 +19,30 @@ class Ending {
void run(); void run();
private: private:
// --- Estados ---
enum class State {
WARMING_UP,
SCENE_0,
SCENE_1,
SCENE_2,
SCENE_3,
SCENE_4,
ENDING
};
// --- Constantes de tiempo (basado en 60 FPS) ---
static constexpr float WARMUP_DURATION = 3.333F; // 200 frames @ 60fps
static constexpr float FADEOUT_DURATION = 1.667F; // 100 frames @ 60fps
static constexpr float SCENE_0_DURATION = 16.667F; // 1000 frames @ 60fps
static constexpr float SCENE_1_DURATION = 23.333F; // 1400 frames @ 60fps
static constexpr float SCENE_2_DURATION = 16.667F; // 1000 frames @ 60fps
static constexpr float SCENE_3_DURATION = 13.333F; // 800 frames @ 60fps
static constexpr float SCENE_4_DURATION = 16.667F; // 1000 frames @ 60fps
static constexpr float TEXT_REVEAL_SPEED = 30.0F; // 2px cada 4 frames @ 60fps
static constexpr float IMAGE_REVEAL_SPEED = 60.0F; // 2px cada 2 frames @ 60fps
static constexpr float TEXT_LAPSE = 1.333F; // 80 frames @ 60fps
static constexpr float FADEOUT_START_OFFSET = 1.667F; // Inicio fade-out 100 frames antes del fin
// --- Estructuras --- // --- Estructuras ---
struct EndingSurface // Estructura con dos texturas y sprites, uno para mostrar y el otro hace de cortinilla struct EndingSurface // Estructura con dos texturas y sprites, uno para mostrar y el otro hace de cortinilla
{ {
@@ -51,27 +76,30 @@ class Ending {
std::shared_ptr<Surface> cover_surface_; // Surface para cubrir el texto std::shared_ptr<Surface> cover_surface_; // Surface para cubrir el texto
// --- Variables --- // --- Variables ---
int counter_; // Contador std::unique_ptr<DeltaTimer> delta_timer_; // Temporizador delta para time-based update
int pre_counter_; // Contador previo State state_ = State::WARMING_UP; // Estado actual
int cover_counter_; // Contador para la cortinilla float state_time_ = 0.0F; // Tiempo acumulado en el estado actual
Uint32 ticks_; // Contador de ticks para ajustar la velocidad del programa float total_time_ = 0.0F; // Tiempo total acumulado desde el inicio
float fadeout_time_ = 0.0F; // Tiempo acumulado para el fade-out
float current_delta_ = 0.0F; // Delta time del frame actual
std::vector<EndingSurface> sprite_texts_; // Vector con los sprites de texto con su cortinilla std::vector<EndingSurface> sprite_texts_; // Vector con los sprites de texto con su cortinilla
std::vector<EndingSurface> sprite_pics_; // Vector con los sprites de texto con su cortinilla std::vector<EndingSurface> sprite_pics_; // Vector con los sprites de texto con su cortinilla
int current_scene_; // Escena actual int current_scene_ = 0; // Escena actual (0-4)
std::vector<SceneData> scenes_; // Vector con los textos e imagenes de cada escena std::vector<SceneData> scenes_; // Vector con los textos e imagenes de cada escena
// --- Funciones --- // --- Funciones ---
void update(); // Actualiza el objeto void update(); // Actualiza el objeto
void render(); // Dibuja el final en pantalla void render(); // Dibuja el final en pantalla
static void checkEvents(); // Comprueba el manejador de eventos static void checkEvents(); // Comprueba el manejador de eventos
static void checkInput(); // Comprueba las entradas static void checkInput(); // Comprueba las entradas
void iniTexts(); // Inicializa los textos void iniTexts(); // Inicializa los textos
void iniPics(); // Inicializa las imagenes void iniPics(); // Inicializa las imagenes
void iniScenes(); // Inicializa las escenas void iniScenes(); // Inicializa las escenas
void updateCounters(); // Actualiza los contadores void updateState(float delta_time); // Actualiza la máquina de estados
void updateSpriteCovers(); // Actualiza las cortinillas de los elementos void transitionToState(State new_state); // Transición entre estados
void checkChangeScene(); // Comprueba si se ha de cambiar de escena void updateSpriteCovers(); // Actualiza las cortinillas de los elementos
void fillCoverTexture(); // Rellena la textura para la cortinilla void checkChangeScene(); // Comprueba si se ha de cambiar de escena
void renderCoverTexture(); // Dibuja la cortinilla de cambio de escena void fillCoverTexture(); // Rellena la textura para la cortinilla
void updateMusicVolume() const; // Actualiza el volumen de la musica void renderCoverTexture(); // Dibuja la cortinilla de cambio de escena
void updateMusicVolume() const; // Actualiza el volumen de la musica
}; };