JailDoctor/jdd_opendingux
1
0
Fork 0
forked from jaildesigner-jailgames/jaildoctors_dilemma
Code Issues Pull Requests Projects Releases Wiki Activity

style: afegides varies animacions amb easing per al Logo

Browse Source
This commit is contained in:
Sergio
2025-11-08 00:10:16 +01:00
parent e9fed353ff
commit 85d34fb907
5 changed files with 327 additions and 38 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 ---
#ifdef _DEBUG
inline Scene current = Scene::GAME; // Escena actual
inline Scene current = Scene::LOGO; // Escena actual
inline Options options = Options::LOGO_TO_LOADING_SCREEN; // Opciones de la escena actual
#else
inline Scene current = Scene::LOGO; // Escena actual

73
source/game/scenes/logo.cpp
View File

@@ -3,6 +3,8 @@
#include <SDL3/SDL.h>
#include <algorithm> // Para std::clamp
#include <array> // Para std::array
#include <random> // Para generador aleatorio
#include "core/audio/audio.hpp" // Para Audio
#include "core/input/global_inputs.hpp" // Para check
@@ -15,6 +17,7 @@
#include "game/options.hpp" // Para Options, SectionState, options, Section
#include "game/scene_manager.hpp" // Para SceneManager
#include "utils/delta_timer.hpp" // Para DeltaTimer
#include "utils/easing_functions.hpp" // Para funciones de suavizado
#include "utils/utils.hpp" // Para PaletteColor
// Constructor
@@ -34,6 +37,19 @@ Logo::Logo()
initSprites(); // Crea los sprites de cada linea
initColors(); // Inicializa el vector de colores
// Seleccionar función de easing aleatoria para la animación del logo
// Usamos lambdas para funciones con parámetros opcionales
static const std::array<EasingFunction, 4> EASING_OPTIONS = {
[](float t) { return Easing::backOut(t); }, // Overshoot retro
[](float t) { return Easing::elasticOut(t); }, // Rebote múltiple con oscilación
Easing::bounceOut, // Rebote físico decreciente
Easing::cubicOut // Suavizado sin overshoot (para variedad)
};
std::random_device rd;
std::mt19937 gen(rd());
std::uniform_int_distribution<size_t> dist(0, EASING_OPTIONS.size() - 1);
easing_function_ = EASING_OPTIONS[dist(gen)];
// Cambia el color del borde
Screen::get()->setBorderColor(static_cast<Uint8>(PaletteColor::BLACK));
}
@@ -59,41 +75,24 @@ void Logo::updateJAILGAMES(float delta_time) {
return;
}
// Calcular el desplazamiento basado en velocidad y delta time
const float DISPLACEMENT = JAILGAMES_SLIDE_SPEED * delta_time;
// Calcular el progreso de la animación (0.0 a 1.0)
const float progress = std::clamp(state_time_ / JAILGAMES_SLIDE_DURATION, 0.0F, 1.0F);
// Actualizar cada línea del sprite JAILGAMES
// Aplicar función de suavizado seleccionada aleatoriamente (permite overshoot para efecto de rebote)
// La posición final exacta se garantiza en updateState() antes de transicionar
const float eased_progress = easing_function_(progress);
// Actualizar cada línea del sprite JAILGAMES interpolando con easing
for (size_t i = 0; i < jailgames_sprite_.size(); ++i) {
const float CURRENT_X = jailgames_sprite_[i]->getX();
// Interpolar entre posición inicial y destino usando el progreso suavizado
const float initial_x = static_cast<float>(jailgames_initial_x_[i]);
const float dest_x = static_cast<float>(JAILGAMES_DEST_X);
const float new_x = initial_x + (dest_x - initial_x) * eased_progress;
// Las líneas pares se mueven desde la derecha, las impares desde la izquierda
if (i % 2 == 0) {
// Mover hacia la izquierda
if (CURRENT_X > JAILGAMES_DEST_X) {
const float NEW_X = CURRENT_X - DISPLACEMENT;
jailgames_sprite_[i]->setX(NEW_X < JAILGAMES_DEST_X ? JAILGAMES_DEST_X : NEW_X);
}
} else {
// Mover hacia la derecha
if (CURRENT_X < JAILGAMES_DEST_X) {
const float NEW_X = CURRENT_X + DISPLACEMENT;
jailgames_sprite_[i]->setX(NEW_X > JAILGAMES_DEST_X ? JAILGAMES_DEST_X : NEW_X);
}
}
jailgames_sprite_[i]->setX(new_x);
}
}
// Verifica si todas las líneas están en su posición destino
auto Logo::allJailgamesLinesInPosition() const -> bool {
// Iterar por todas las líneas (empezando desde 1, como en updateJAILGAMES)
for (size_t i = 0; i < jailgames_sprite_.size(); ++i) {
if (jailgames_sprite_[i]->getX() != JAILGAMES_DEST_X) {
return false; // Al menos una línea no ha llegado
}
}
return true; // Todas las líneas están en posición
}
// Calcula el índice de color según el progreso (0.0-1.0)
auto Logo::getColorIndex(float progress) const -> int {
// Asegurar que progress esté en el rango [0.0, 1.0]
@@ -157,7 +156,12 @@ void Logo::updateState(float delta_time) {
break;
case State::JAILGAMES_SLIDE_IN:
if (allJailgamesLinesInPosition()) {
if (state_time_ >= JAILGAMES_SLIDE_DURATION) {
// Garantizar que todas las líneas estén exactamente en la posición final
// antes de transicionar (previene race condition con updateJAILGAMES)
for (auto& sprite : jailgames_sprite_) {
sprite->setX(JAILGAMES_DEST_X);
}
transitionToState(State::SINCE_1998_FADE_IN);
}
break;
@@ -263,10 +267,17 @@ void Logo::initColors() {
// Crea los sprites de cada linea
void Logo::initSprites() {
const float WIDTH = jailgames_surface_->getWidth();
jailgames_initial_x_.reserve(jailgames_surface_->getHeight());
for (int i = 0; i < jailgames_surface_->getHeight(); ++i) {
jailgames_sprite_.push_back(std::make_shared<SurfaceSprite>(jailgames_surface_, 0, i, jailgames_surface_->getWidth(), 1));
jailgames_sprite_.back()->setClip(0, i, jailgames_surface_->getWidth(), 1);
jailgames_sprite_.at(i)->setX((i % 2 == 0) ? (256 + (i * 3)) : (-WIDTH - (i * 3)));
// Calcular posición inicial (alternando entre derecha e izquierda)
const int initial_x = (i % 2 == 0) ? (256 + (i * 3)) : (static_cast<int>(-WIDTH) - (i * 3));
jailgames_initial_x_.push_back(initial_x);
jailgames_sprite_.at(i)->setX(initial_x);
jailgames_sprite_.at(i)->setY(83 + i);
}
}

15
source/game/scenes/logo.hpp
View File

@@ -2,8 +2,9 @@
#include <SDL3/SDL.h>
#include <memory> // Para shared_ptr
#include <vector> // Para vector
#include <functional> // Para std::function
#include <memory> // Para shared_ptr
#include <vector> // Para vector
#include "utils/delta_timer.hpp" // Para DeltaTimer
class SurfaceSprite; // Forward declaration
@@ -11,6 +12,9 @@ class Surface; // Forward declaration
class Logo {
public:
// --- Tipos ---
using EasingFunction = std::function<float(float)>; // Función de easing (permite lambdas)
// --- Enumeraciones ---
enum class State {
INITIAL, // Espera inicial
@@ -36,13 +40,14 @@ class Logo {
static constexpr float FADE_OUT_DURATION = 0.5F; // Duración del fade-out final
// --- Constantes de animación ---
static constexpr float JAILGAMES_SLIDE_SPEED = 350.0F; // Velocidad de slide-in (pixels/segundo)
static constexpr int JAILGAMES_DEST_X = 37; // Posición X de destino para JAILGAMES
static constexpr float JAILGAMES_SLIDE_DURATION = 0.8F; // Duración de la animación de slide-in (segundos)
static constexpr int JAILGAMES_DEST_X = 37; // Posición X de destino para JAILGAMES
// --- Objetos y punteros ---
std::shared_ptr<Surface> jailgames_surface_ = nullptr; // Textura con los graficos "JAILGAMES"
std::shared_ptr<Surface> since_1998_surface_ = nullptr; // Textura con los graficos "Since 1998"
std::vector<std::shared_ptr<SurfaceSprite>> jailgames_sprite_; // Vector con los sprites de cada linea que forman el bitmap JAILGAMES
std::vector<int> jailgames_initial_x_; // Posiciones X iniciales de cada línea (para interpolación con easing)
std::shared_ptr<SurfaceSprite> since_1998_sprite_ = nullptr; // SSprite para manejar la textura2
Uint8 jailgames_color_ = 0; // Color para el sprite de "JAILGAMES"
Uint8 since_1998_color_ = 0; // Color para el sprite de "Since 1998"
@@ -52,6 +57,7 @@ class Logo {
std::unique_ptr<DeltaTimer> delta_timer_ = nullptr; // Timer para delta time
State state_ = State::INITIAL; // Estado actual de la secuencia
float state_time_ = 0.0F; // Tiempo acumulado en el estado actual
EasingFunction easing_function_; // Función de easing para la animación del logo
// --- Funciones ---
void update(); // Actualiza las variables
@@ -63,7 +69,6 @@ class Logo {
void updateState(float delta_time); // Actualiza el estado actual
void transitionToState(State new_state); // Transiciona a un nuevo estado
[[nodiscard]] auto getColorIndex(float progress) const -> int; // Calcula el índice de color según el progreso (0.0-1.0)
[[nodiscard]] auto allJailgamesLinesInPosition() const -> bool; // Verifica si todas las líneas están en su posición destino
static void endSection(); // Termina la sección
void initColors(); // Inicializa el vector de colores
void initSprites(); // Crea los sprites de cada linea