jaildoctors_dilemma/source/game/scenes/ending.cpp

#include "game/scenes/ending.hpp"

#include <SDL3/SDL.h>

#include <algorithm>  // Para min

#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/rendering/text.hpp"            // Para Text, TEXT_STROKE
#include "core/resources/resource.hpp"        // Para Resource
#include "external/jail_audio.h"              // Para JA_SetVolume, JA_PlayMusic, JA_StopMusic
#include "game/options.hpp"                   // Para Options, options, OptionsGame, SectionS...
#include "game/scene_manager.hpp"             // Para SceneManager
#include "utils/defines.hpp"                  // Para GAME_SPEED
#include "core/system/global_events.hpp"      // Para check
#include "utils/utils.hpp"                    // Para PaletteColor

// Constructor
Ending::Ending()
    : counter_(-1),
      pre_counter_(0),
      cover_counter_(0),
      ticks_(0),
      current_scene_(0) {
    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() {
    // Comprueba que la diferencia de ticks sea mayor a la velocidad del juego
    if (SDL_GetTicks() - ticks_ > GAME_SPEED) {
        // Actualiza el contador de ticks
        ticks_ = SDL_GetTicks();

        // Comprueba las entradas
        checkInput();

        // Actualiza el contador
        updateCounters();

        // Actualiza las cortinillas de los elementos
        updateSpriteCovers();

        // Comprueba si se ha de cambiar de escena
        checkChangeScene();

        // Actualiza el volumen de la musica
        updateMusicVolume();

        // Actualiza el objeto Screen
        Screen::get()->update();
    }
}

// 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));

    // 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) {
        if (counter_ > ti.trigger) {
            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::checkEvents() {
    SDL_Event event;
    while (SDL_PollEvent(&event)) {
        GlobalEvents::check(event);
    }
}

// Comprueba las entradas
void Ending::checkInput() {
    GlobalInputs::check();
}

// 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::get()->getText("smb2");

        const float WIDTH = text->lenght(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, 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::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() {
    JA_PlayMusic(Resource::get()->getMusic("ending1.ogg"));

    while (SceneManager::current == SceneManager::Scene::ENDING) {
        update();
        checkEvents();
        render();
    }

    JA_StopMusic();
    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
void Ending::updateSpriteCovers() {
    // Actualiza la cortinilla de los textos
    if (counter_ % 4 == 0) {
        for (auto ti : scenes_.at(current_scene_).text_index) {
            if (counter_ > ti.trigger) {
                if (sprite_texts_.at(ti.index).cover_clip_desp > 0) {
                    sprite_texts_.at(ti.index).cover_clip_desp -= 2;
                } else if (sprite_texts_.at(ti.index).cover_clip_height > 0) {
                    sprite_texts_.at(ti.index).cover_clip_height -= 2;
                    sprite_texts_.at(ti.index).cover_sprite->setY(sprite_texts_.at(ti.index).cover_sprite->getY() + 2);
                }
                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
    if (counter_ % 2 == 0) {
        if (sprite_pics_.at(current_scene_).cover_clip_desp > 0) {
            sprite_pics_.at(current_scene_).cover_clip_desp -= 2;
        } else if (sprite_pics_.at(current_scene_).cover_clip_height > 0) {
            sprite_pics_.at(current_scene_).cover_clip_height -= 2;
            sprite_pics_.at(current_scene_).cover_clip_height = std::max(sprite_pics_.at(current_scene_).cover_clip_height, 0);
            sprite_pics_.at(current_scene_).cover_sprite->setY(sprite_pics_.at(current_scene_).cover_sprite->getY() + 2);
        }
        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
void Ending::checkChangeScene() {
    if (counter_ > scenes_[current_scene_].counter_end) {
        current_scene_++;
        counter_ = 0;
        cover_counter_ = 0;
        if (current_scene_ == 5) {
            // Termina el bucle
            SceneManager::current = SceneManager::Scene::ENDING2;

            // Mantiene los valores anteriores
            current_scene_ = 4;
            cover_counter_ = 100;
        }
    }
}

// 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 (cover_counter_ > 0) {
        // Dibuja la textura que cubre el texto
        const int OFFSET = std::min(cover_counter_, 100);
        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};
        cover_surface_->render(&src_rect, &dst_rect);
    }
}

// Actualiza el volumen de la musica
void Ending::updateMusicVolume() const {
    if (current_scene_ == 4 && cover_counter_ > 0) {
        const float STEP = (100.0F - cover_counter_) / 100.0F;
        const int VOLUME = 128 * STEP;
        JA_SetVolume(VOLUME);
    }
}