581 lines
20 KiB
C++
581 lines
20 KiB
C++
#include "game/scenes/ending.hpp"
|
|
|
|
#include <SDL3/SDL.h>
|
|
|
|
#include <algorithm> // Para min
|
|
|
|
#include "core/audio/audio.hpp" // Para Audio
|
|
#include "core/input/global_inputs.hpp" // Para check
|
|
#include "core/input/input.hpp" // Para Input
|
|
#include "core/rendering/screen.hpp" // Para Screen
|
|
#include "core/rendering/surface.hpp" // Para Surface
|
|
#include "core/rendering/surface_sprite.hpp" // Para SSprite
|
|
#include "core/rendering/text.hpp" // Para Text, TEXT_STROKE
|
|
#include "core/resources/resource_cache.hpp" // Para Resource
|
|
#include "core/system/global_events.hpp" // Para check
|
|
#include "game/options.hpp" // Para Options, options, OptionsGame, SectionS...
|
|
#include "game/scene_manager.hpp" // Para SceneManager
|
|
#include "utils/defines.hpp" // Para GAME_SPEED
|
|
#include "utils/delta_timer.hpp" // Para DeltaTimer
|
|
#include "utils/utils.hpp" // Para PaletteColor
|
|
|
|
// Constructor
|
|
Ending::Ending()
|
|
: delta_timer_(std::make_unique<DeltaTimer>()) {
|
|
SceneManager::current = SceneManager::Scene::ENDING;
|
|
SceneManager::options = SceneManager::Options::NONE;
|
|
|
|
// Inicializa los textos
|
|
iniTexts();
|
|
|
|
// Inicializa las imagenes
|
|
iniPics();
|
|
|
|
// Inicializa las escenas
|
|
iniScenes();
|
|
|
|
// Cambia el color del borde
|
|
Screen::get()->setBorderColor(static_cast<Uint8>(PaletteColor::BLACK));
|
|
|
|
// Crea la textura para cubrir el texto
|
|
cover_surface_ = std::make_shared<Surface>(Options::game.width, Options::game.height + 8);
|
|
|
|
// Rellena la textura para la cortinilla
|
|
fillCoverTexture();
|
|
}
|
|
|
|
// Actualiza el objeto
|
|
void Ending::update() {
|
|
const float DELTA_TIME = delta_timer_->tick();
|
|
total_time_ += DELTA_TIME; // Actualiza el tiempo total
|
|
|
|
handleEvents(); // Comprueba los eventos
|
|
handleInput(); // Comprueba las entradas
|
|
|
|
updateState(DELTA_TIME); // Actualiza la máquina de estados
|
|
updateSpriteCovers(); // Actualiza las cortinillas de los elementos
|
|
|
|
Audio::update(); // Actualiza el objeto Audio
|
|
Screen::get()->update(DELTA_TIME); // Actualiza el objeto Screen
|
|
}
|
|
|
|
// Dibuja el final en pantalla
|
|
void Ending::render() {
|
|
// Prepara para empezar a dibujar en la textura de juego
|
|
Screen::get()->start();
|
|
|
|
// Limpia la pantalla
|
|
Screen::get()->clearSurface(static_cast<Uint8>(PaletteColor::BLACK));
|
|
|
|
// Skip rendering durante WARMING_UP
|
|
if (state_ != State::WARMING_UP) {
|
|
// 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
|
|
for (const auto& ti : scenes_.at(current_scene_).text_index) {
|
|
// Convertir trigger de frames a segundos @ 60fps
|
|
const float TRIGGER_TIME = static_cast<float>(ti.trigger) / 60.0F;
|
|
|
|
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
|
|
renderCoverTexture();
|
|
}
|
|
|
|
// Vuelca el contenido del renderizador en pantalla
|
|
Screen::get()->render();
|
|
}
|
|
|
|
// Comprueba el manejador de eventos
|
|
void Ending::handleEvents() {
|
|
SDL_Event event;
|
|
while (SDL_PollEvent(&event)) {
|
|
GlobalEvents::handle(event);
|
|
}
|
|
}
|
|
|
|
// Comprueba las entradas
|
|
void Ending::handleInput() {
|
|
Input::get()->update();
|
|
GlobalInputs::handle();
|
|
}
|
|
|
|
// 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
|
|
void Ending::iniTexts() {
|
|
// Vector con los textos
|
|
std::vector<TextAndPosition> texts;
|
|
|
|
// Escena #0
|
|
texts.push_back({"HE FINALLY MANAGED", 32});
|
|
texts.push_back({"TO GET TO THE JAIL", 42});
|
|
texts.push_back({"WITH ALL HIS PROJECTS", 142});
|
|
texts.push_back({"READY TO BE FREED", 152});
|
|
|
|
// Escena #1
|
|
texts.push_back({"ALL THE JAILERS WERE THERE", 1});
|
|
texts.push_back({"WAITING FOR THE JAILGAMES", 11});
|
|
texts.push_back({"TO BE RELEASED", 21});
|
|
|
|
texts.push_back({"THERE WERE EVEN BARRULLS AND", 161});
|
|
texts.push_back({"BEGINNERS AMONG THE CROWD", 171});
|
|
|
|
texts.push_back({"BRY WAS CRYING...", 181});
|
|
|
|
// Escena #2
|
|
texts.push_back({"BUT SUDDENLY SOMETHING", 19});
|
|
texts.push_back({"CAUGHT HIS ATTENTION", 29});
|
|
|
|
// Escena #3
|
|
texts.push_back({"A PILE OF JUNK!", 36});
|
|
texts.push_back({"FULL OF NON WORKING TRASH!!", 46});
|
|
|
|
// Escena #4
|
|
texts.push_back({"AND THEN,", 36});
|
|
texts.push_back({"FOURTY NEW PROJECTS", 46});
|
|
texts.push_back({"WERE BORN...", 158});
|
|
|
|
// Crea los sprites
|
|
sprite_texts_.clear();
|
|
|
|
for (const auto& txt : texts) {
|
|
auto text = Resource::Cache::get()->getText("smb2");
|
|
|
|
const float WIDTH = text->length(txt.caption, 1) + 2 + 2;
|
|
const float HEIGHT = text->getCharacterSize() + 2 + 2;
|
|
auto text_color = static_cast<Uint8>(PaletteColor::WHITE);
|
|
auto shadow_color = static_cast<Uint8>(PaletteColor::BLACK);
|
|
|
|
EndingSurface st;
|
|
|
|
// Crea la textura
|
|
st.image_surface = std::make_shared<Surface>(WIDTH, HEIGHT);
|
|
auto previuos_renderer = Screen::get()->getRendererSurface();
|
|
Screen::get()->setRendererSurface(st.image_surface);
|
|
text->writeDX(Text::STROKE_FLAG, 2, 2, txt.caption, 1, text_color, 2, shadow_color);
|
|
|
|
// Crea el sprite
|
|
st.image_sprite = std::make_shared<SurfaceSprite>(st.image_surface, 0, 0, st.image_surface->getWidth(), st.image_surface->getHeight());
|
|
st.image_sprite->setPosition((Options::game.width - st.image_surface->getWidth()) / 2, txt.pos);
|
|
|
|
// Crea la cover_surface
|
|
st.cover_surface = std::make_shared<Surface>(WIDTH, HEIGHT + 8);
|
|
Screen::get()->setRendererSurface(st.cover_surface);
|
|
|
|
// Rellena la cover_surface con color transparente
|
|
st.cover_surface->clear(static_cast<Uint8>(PaletteColor::TRANSPARENT));
|
|
|
|
// Crea una malla de 8 pixels de alto
|
|
auto surface = Screen::get()->getRendererSurface();
|
|
auto color = static_cast<Uint8>(PaletteColor::BLACK);
|
|
for (int i = 0; i < WIDTH; i += 2) {
|
|
surface->putPixel(i, 0, color);
|
|
surface->putPixel(i, 2, color);
|
|
surface->putPixel(i, 4, color);
|
|
surface->putPixel(i, 6, color);
|
|
|
|
surface->putPixel(i + 1, 5, color);
|
|
surface->putPixel(i + 1, 7, color);
|
|
}
|
|
|
|
// El resto se rellena de color sólido
|
|
SDL_FRect rect = {0, 8, WIDTH, HEIGHT};
|
|
surface->fillRect(&rect, color);
|
|
|
|
// Crea el sprite
|
|
st.cover_sprite = std::make_shared<SurfaceSprite>(st.cover_surface, 0, 0, st.cover_surface->getWidth(), st.cover_surface->getHeight() - 8);
|
|
st.cover_sprite->setPosition((Options::game.width - st.cover_surface->getWidth()) / 2, txt.pos);
|
|
st.cover_sprite->setClip(0, 8, st.cover_surface->getWidth(), st.cover_surface->getHeight());
|
|
|
|
// Inicializa variables
|
|
st.cover_clip_desp = 8;
|
|
st.cover_clip_height = HEIGHT;
|
|
|
|
sprite_texts_.push_back(st);
|
|
Screen::get()->setRendererSurface(previuos_renderer);
|
|
}
|
|
}
|
|
|
|
// Inicializa las imagenes
|
|
void Ending::iniPics() {
|
|
// Vector con las rutas y la posición
|
|
std::vector<TextAndPosition> pics;
|
|
|
|
pics.push_back({"ending1.gif", 48});
|
|
pics.push_back({"ending2.gif", 26});
|
|
pics.push_back({"ending3.gif", 29});
|
|
pics.push_back({"ending4.gif", 63});
|
|
pics.push_back({"ending5.gif", 53});
|
|
|
|
// Crea los sprites
|
|
sprite_pics_.clear();
|
|
|
|
for (const auto& pic : pics) {
|
|
EndingSurface sp;
|
|
|
|
// Crea la texture
|
|
sp.image_surface = Resource::Cache::get()->getSurface(pic.caption);
|
|
sp.image_surface->setTransparentColor();
|
|
const float WIDTH = sp.image_surface->getWidth();
|
|
const float HEIGHT = sp.image_surface->getHeight();
|
|
|
|
// Crea el sprite
|
|
sp.image_sprite = std::make_shared<SurfaceSprite>(sp.image_surface, 0, 0, WIDTH, HEIGHT);
|
|
sp.image_sprite->setPosition((Options::game.width - WIDTH) / 2, pic.pos);
|
|
|
|
// Crea la cover_surface
|
|
sp.cover_surface = std::make_shared<Surface>(WIDTH, HEIGHT + 8);
|
|
auto previuos_renderer = Screen::get()->getRendererSurface();
|
|
Screen::get()->setRendererSurface(sp.cover_surface);
|
|
|
|
// Rellena la cover_surface con color transparente
|
|
sp.cover_surface->clear(static_cast<Uint8>(PaletteColor::TRANSPARENT));
|
|
|
|
// Crea una malla en los primeros 8 pixels
|
|
auto surface = Screen::get()->getRendererSurface();
|
|
auto color = static_cast<Uint8>(PaletteColor::BLACK);
|
|
for (int i = 0; i < WIDTH; i += 2) {
|
|
surface->putPixel(i, 0, color);
|
|
surface->putPixel(i, 2, color);
|
|
surface->putPixel(i, 4, color);
|
|
surface->putPixel(i, 6, color);
|
|
|
|
surface->putPixel(i + 1, 5, color);
|
|
surface->putPixel(i + 1, 7, color);
|
|
}
|
|
|
|
// El resto se rellena de color sólido
|
|
SDL_FRect rect = {0.0F, 8.0F, WIDTH, HEIGHT};
|
|
surface->fillRect(&rect, color);
|
|
|
|
// Crea el sprite
|
|
sp.cover_sprite = std::make_shared<SurfaceSprite>(sp.cover_surface, 0, 0, sp.cover_surface->getWidth(), sp.cover_surface->getHeight() - 8);
|
|
sp.cover_sprite->setPosition((Options::game.width - sp.cover_surface->getWidth()) / 2, pic.pos);
|
|
sp.cover_sprite->setClip(0, 8, sp.cover_surface->getWidth(), sp.cover_surface->getHeight());
|
|
|
|
// Inicializa variables
|
|
sp.cover_clip_desp = 8;
|
|
sp.cover_clip_height = HEIGHT;
|
|
|
|
sprite_pics_.push_back(sp);
|
|
Screen::get()->setRendererSurface(previuos_renderer);
|
|
}
|
|
}
|
|
|
|
// Inicializa las escenas
|
|
void Ending::iniScenes() {
|
|
// Variable para los tiempos
|
|
int trigger;
|
|
constexpr int LAPSE = 80;
|
|
|
|
// Crea el contenedor
|
|
SceneData sc;
|
|
|
|
// Inicializa el vector
|
|
scenes_.clear();
|
|
|
|
// Crea la escena #0
|
|
sc.counter_end = 1000;
|
|
sc.picture_index = 0;
|
|
sc.text_index.clear();
|
|
trigger = 85 * 2;
|
|
trigger += LAPSE;
|
|
sc.text_index.push_back({0, trigger});
|
|
trigger += LAPSE;
|
|
sc.text_index.push_back({1, trigger});
|
|
trigger += LAPSE * 3;
|
|
sc.text_index.push_back({2, trigger});
|
|
trigger += LAPSE;
|
|
sc.text_index.push_back({3, trigger});
|
|
scenes_.push_back(sc);
|
|
|
|
// Crea la escena #1
|
|
sc.counter_end = 1400;
|
|
sc.picture_index = 1;
|
|
sc.text_index.clear();
|
|
trigger = 140 * 2;
|
|
trigger += LAPSE;
|
|
sc.text_index.push_back({4, trigger});
|
|
trigger += LAPSE;
|
|
sc.text_index.push_back({5, trigger});
|
|
trigger += LAPSE;
|
|
sc.text_index.push_back({6, trigger});
|
|
trigger += LAPSE * 3;
|
|
sc.text_index.push_back({7, trigger});
|
|
trigger += LAPSE;
|
|
sc.text_index.push_back({8, trigger});
|
|
trigger += LAPSE * 3;
|
|
sc.text_index.push_back({9, trigger});
|
|
scenes_.push_back(sc);
|
|
|
|
// Crea la escena #2
|
|
sc.counter_end = 1000;
|
|
sc.picture_index = 2;
|
|
sc.text_index.clear();
|
|
trigger = 148 / 2;
|
|
trigger += LAPSE;
|
|
sc.text_index.push_back({10, trigger});
|
|
trigger += LAPSE;
|
|
sc.text_index.push_back({11, trigger});
|
|
scenes_.push_back(sc);
|
|
|
|
// Crea la escena #3
|
|
sc.counter_end = 800;
|
|
sc.picture_index = 3;
|
|
sc.text_index.clear();
|
|
trigger = 87 / 2;
|
|
trigger += LAPSE;
|
|
sc.text_index.push_back({12, trigger});
|
|
trigger += LAPSE / 2;
|
|
sc.text_index.push_back({13, trigger});
|
|
scenes_.push_back(sc);
|
|
|
|
// Crea la escena #4
|
|
sc.counter_end = 1000;
|
|
sc.picture_index = 4;
|
|
sc.text_index.clear();
|
|
trigger = 91 * 2;
|
|
trigger += LAPSE;
|
|
sc.text_index.push_back({14, trigger});
|
|
trigger += LAPSE * 2;
|
|
sc.text_index.push_back({15, trigger});
|
|
trigger += LAPSE * 3;
|
|
sc.text_index.push_back({16, trigger});
|
|
scenes_.push_back(sc);
|
|
}
|
|
|
|
// Bucle principal
|
|
void Ending::run() {
|
|
Audio::get()->playMusic("ending1.ogg");
|
|
|
|
while (SceneManager::current == SceneManager::Scene::ENDING) {
|
|
update();
|
|
render();
|
|
}
|
|
|
|
Audio::get()->stopMusic();
|
|
}
|
|
|
|
// Actualiza las cortinillas de los elementos
|
|
void Ending::updateSpriteCovers() {
|
|
// Skip durante WARMING_UP
|
|
if (state_ == State::WARMING_UP) {
|
|
return;
|
|
}
|
|
|
|
// Actualiza la cortinilla de los textos
|
|
for (const auto& ti : scenes_.at(current_scene_).text_index) {
|
|
// Convertir trigger de frames a segundos @ 60fps
|
|
const float TRIGGER_TIME = static_cast<float>(ti.trigger) / 60.0F;
|
|
|
|
if (state_time_ > TRIGGER_TIME) {
|
|
// Tiempo transcurrido desde que se activó el trigger
|
|
const float TIME_SINCE_TRIGGER = state_time_ - TRIGGER_TIME;
|
|
|
|
// Píxeles revelados: tiempo * velocidad
|
|
const float PIXELS_REVEALED = TIME_SINCE_TRIGGER * TEXT_REVEAL_SPEED;
|
|
|
|
// Obtiene el sprite
|
|
auto SPRITE_TEXT = sprite_texts_.at(ti.index);
|
|
|
|
// Obtener altura inicial de la superficie
|
|
const float INITIAL_HEIGHT = SPRITE_TEXT.image_surface->getHeight();
|
|
const float Y_INITIAL = SPRITE_TEXT.image_sprite->getY();
|
|
|
|
// Fase 1: Revelar malla decorativa (8 píxeles)
|
|
if (PIXELS_REVEALED < 8.0F) {
|
|
SPRITE_TEXT.cover_clip_desp = static_cast<int>(8.0F - PIXELS_REVEALED);
|
|
SPRITE_TEXT.cover_clip_height = static_cast<int>(INITIAL_HEIGHT);
|
|
SPRITE_TEXT.cover_sprite->setY(Y_INITIAL);
|
|
}
|
|
// Fase 2: Revelar contenido
|
|
else {
|
|
SPRITE_TEXT.cover_clip_desp = 0;
|
|
const int CONTENT_PIXELS = PIXELS_REVEALED - 8.0F;
|
|
SPRITE_TEXT.cover_clip_height = std::max(0, static_cast<int>(INITIAL_HEIGHT - CONTENT_PIXELS));
|
|
SPRITE_TEXT.cover_sprite->setY(Y_INITIAL + static_cast<int>(CONTENT_PIXELS));
|
|
}
|
|
|
|
SPRITE_TEXT.cover_sprite->setClip(
|
|
0,
|
|
SPRITE_TEXT.cover_clip_desp,
|
|
SPRITE_TEXT.cover_sprite->getWidth(),
|
|
SPRITE_TEXT.cover_clip_height);
|
|
}
|
|
}
|
|
|
|
// Actualiza la cortinilla de las imágenes (revelación continua desde el inicio de la escena)
|
|
auto SPRITE_PICS = sprite_pics_.at(current_scene_);
|
|
const float PIXELS_REVEALED = state_time_ * IMAGE_REVEAL_SPEED;
|
|
const float INITIAL_HEIGHT = SPRITE_PICS.image_surface->getHeight();
|
|
const float Y_INITIAL = SPRITE_PICS.image_sprite->getY();
|
|
|
|
// Fase 1: Revelar malla decorativa (8 píxeles)
|
|
if (PIXELS_REVEALED < 8.0F) {
|
|
SPRITE_PICS.cover_clip_desp = static_cast<int>(8.0F - PIXELS_REVEALED);
|
|
SPRITE_PICS.cover_clip_height = static_cast<int>(INITIAL_HEIGHT);
|
|
SPRITE_PICS.cover_sprite->setY(Y_INITIAL);
|
|
}
|
|
// Fase 2: Revelar contenido
|
|
else {
|
|
SPRITE_PICS.cover_clip_desp = 0;
|
|
const int CONTENT_PIXELS = PIXELS_REVEALED - 8.0F;
|
|
SPRITE_PICS.cover_clip_height = std::max(0, static_cast<int>(INITIAL_HEIGHT - CONTENT_PIXELS));
|
|
SPRITE_PICS.cover_sprite->setY(Y_INITIAL + static_cast<int>(CONTENT_PIXELS));
|
|
}
|
|
|
|
SPRITE_PICS.cover_sprite->setClip(0, SPRITE_PICS.cover_clip_desp, SPRITE_PICS.cover_sprite->getWidth(), SPRITE_PICS.cover_clip_height);
|
|
}
|
|
|
|
// Comprueba si se ha de cambiar de escena
|
|
void Ending::checkChangeScene() {
|
|
// Obtener duración de la escena actual
|
|
float current_duration = 0.0F;
|
|
State next_state = State::ENDING;
|
|
|
|
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
|
|
SceneManager::current = SceneManager::Scene::ENDING2;
|
|
} else {
|
|
// Transición a la siguiente escena
|
|
current_scene_++;
|
|
transitionToState(next_state);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Rellena la textura para la cortinilla
|
|
void Ending::fillCoverTexture() {
|
|
// Rellena la textura que cubre el texto con color transparente
|
|
auto previuos_renderer = Screen::get()->getRendererSurface();
|
|
Screen::get()->setRendererSurface(cover_surface_);
|
|
cover_surface_->clear(static_cast<Uint8>(PaletteColor::TRANSPARENT));
|
|
|
|
// Los primeros 8 pixels crea una malla
|
|
const auto COLOR = static_cast<Uint8>(PaletteColor::BLACK);
|
|
auto surface = Screen::get()->getRendererSurface();
|
|
for (int i = 0; i < 256; i += 2) {
|
|
surface->putPixel(i + 0, Options::game.height + 0, COLOR);
|
|
surface->putPixel(i + 1, Options::game.height + 1, COLOR);
|
|
surface->putPixel(i + 0, Options::game.height + 2, COLOR);
|
|
surface->putPixel(i + 1, Options::game.height + 3, COLOR);
|
|
|
|
surface->putPixel(i, Options::game.height + 4, COLOR);
|
|
surface->putPixel(i, Options::game.height + 6, COLOR);
|
|
}
|
|
|
|
// El resto se rellena de color sólido
|
|
SDL_FRect rect = {0, 0, 256, Options::game.height};
|
|
surface->fillRect(&rect, COLOR);
|
|
|
|
Screen::get()->setRendererSurface(previuos_renderer);
|
|
}
|
|
|
|
// Dibuja la cortinilla de cambio de escena
|
|
void Ending::renderCoverTexture() {
|
|
if (fadeout_time_ > 0.0F) {
|
|
// Convertir fadeout_time_ a equivalente de cover_counter_ @ 60fps
|
|
const float FADEOUT_COUNTER = std::min(fadeout_time_ * 60.0F, 100.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);
|
|
}
|
|
} |