aee-arcade/source/game/scenes/logo_scene.cpp

#include "game/scenes/logo_scene.hpp"

#include <SDL3/SDL.h>

#include <algorithm>
#include <cstdint>
#include <iostream>
#include <utility>

#include "core/audio/audio.hpp"
#include "core/input/global_inputs.hpp"
#include "core/rendering/notifier.hpp"
#include "core/rendering/render_info.hpp"
#include "core/rendering/screen.hpp"
#include "core/rendering/surface.hpp"
#include "core/system/event_buffer.hpp"
#include "core/ui/ui_config.hpp"
#include "game/options.hpp"
#include "game/scenes/placeholder_input.hpp"
#include "game/scenes/scene_flow.hpp"
#include "utils/defines.hpp"

namespace {

    // TODO: migrar a un logger unificat quan es decideixi (veure INC-03 a
    // docs/audit-core-rendering.md). De moment std::cout per rastrejar el
    // flux d'escenes als smoke runs.
    const char* const SCENE_NAME = "LOGO";

}  // namespace

LogoScene::LogoScene(std::shared_ptr<Surface> logo, bool reset)
    : logo_(std::move(logo)) {
    std::cout << "[scene] " << SCENE_NAME << (reset ? " start (reset)\n" : " start\n");
    if (reset) {
        if (auto* audio = Audio::get(); audio != nullptr) {
            audio->stopMusic();
            audio->stopAllSounds();
        }
    }
    // Arrenquem en BLACK_INTRO: ni so ni efecte. El glitch sound i el
    // begin() de scan_ es disparen quan entrem a SCAN.
}

LogoScene::~LogoScene() = default;

auto LogoScene::wantsSkip() -> bool {
    return std::ranges::any_of(EventBuffer::events, [](const SDL_Event& ev) {
        return ev.type == SDL_EVENT_KEY_DOWN && !Placeholder::isReservedScancode(ev.key.scancode);
    });
}

void LogoScene::enterScan() {
    phase_ = Phase::SCAN;
    phase_elapsed_ms_ = 0;
    // So del scanline reveal: una sola pulsació al començament de la
    // fase SCAN, en grup INTERFACE perquè no es vegi afectat pel volum
    // de sons del joc i quedi sempre audible.
    if (auto* audio = Audio::get(); audio != nullptr) {
        audio->playSound(UiConfig::get().logoGlitchSound(), Audio::Group::INTERFACE);
    }
    // Arranca el revelat CRT: el primer frame ja pinta zero files (banda
    // damunt del logo) i avança fins a tenir-lo visible al final.
    const auto& s = UiConfig::get().logoScan();
    scan_.begin({
        .duration_ms = s.duration_ms,
        .band_height_px = s.band_height_px,
        .band_alpha = s.band_alpha,
        .band_pulse_hz = s.band_pulse_hz,
        .band_pulse_depth = s.band_pulse_depth,
        .glitch_amplitude_px = s.glitch_amplitude_px,
        .glitch_band_radius_px = s.glitch_band_radius_px,
        .vhs_burst_per_sec = s.vhs_burst_per_sec,
        .vhs_burst_duration_ms = s.vhs_burst_duration_ms,
        .vhs_burst_height_px = s.vhs_burst_height_px,
        .vhs_burst_amplitude_px = s.vhs_burst_amplitude_px,
        .flash_ms = s.flash_ms,
        .tail_glitch_ms = s.tail_glitch_ms,
    });
}

void LogoScene::enterHoldSilent() {
    phase_ = Phase::HOLD_SILENT;
    phase_elapsed_ms_ = 0;
}

void LogoScene::enterHoldMusic() {
    phase_ = Phase::HOLD_MUSIC;
    phase_elapsed_ms_ = 0;
    // Música del títol al començament d'aquesta fase. La crida és
    // idempotent (Audio detecta same-track + same-loop i no reinicia),
    // així que TitleScene podrà fer el seu propi playMusic sense
    // interrompre la pista durant el FADE_OUT i el BLACK_OUTRO.
    if (auto* audio = Audio::get(); audio != nullptr) {
        audio->playMusic("title.ogg", -1);
    }
}

void LogoScene::enterFadeOut() {
    phase_ = Phase::FADE_OUT;
    phase_elapsed_ms_ = 0;
    fade_.begin(UiConfig::get().logoTimeline().fade_out_ms, Transitions::FadeToBlack::Direction::FADE_OUT);
}

void LogoScene::enterBlackOutro() {
    phase_ = Phase::BLACK_OUTRO;
    phase_elapsed_ms_ = 0;
}

void LogoScene::enterDone() {
    phase_ = Phase::DONE;
    exit_request_ = ExitRequest{.next = SceneId::TITLE, .params = TitleParams{}};
}

void LogoScene::update(int delta_ms) {
    GlobalInputs::update(delta_ms);
    if (GlobalInputs::wantsQuit()) {
        wants_quit_ = true;
        return;
    }

    // Skip: qualsevol tecla no reservada salta directament a la
    // transició cap a TITLE. El propi TitleScene fa el seu fade-in
    // inicial des de negre, així que la sortida no queda abrupta.
    if (phase_ != Phase::DONE && wantsSkip()) {
        enterDone();
    }

    if (phase_ != Phase::DONE) {
        phase_elapsed_ms_ += delta_ms;
        // Tick dels efectes actius. Tots dos són no-op si el seu
        // duration_ms intern està a 0; només cal cridar-los si la fase
        // corresponent està viva o just acabada.
        scan_.tick(delta_ms);
        fade_.tick(delta_ms);
    }

    const auto& tl = UiConfig::get().logoTimeline();
    switch (phase_) {
        case Phase::BLACK_INTRO:
            if (phase_elapsed_ms_ >= tl.black_intro_ms) { enterScan(); }
            break;
        case Phase::SCAN:
            if (scan_.isFinished()) { enterHoldSilent(); }
            break;
        case Phase::HOLD_SILENT:
            if (phase_elapsed_ms_ >= tl.hold_silent_ms) { enterHoldMusic(); }
            break;
        case Phase::HOLD_MUSIC:
            if (phase_elapsed_ms_ >= tl.hold_with_music_ms) { enterFadeOut(); }
            break;
        case Phase::FADE_OUT:
            if (phase_elapsed_ms_ >= tl.fade_out_ms) { enterBlackOutro(); }
            break;
        case Phase::BLACK_OUTRO:
            if (phase_elapsed_ms_ >= tl.black_outro_ms) { enterDone(); }
            break;
        case Phase::DONE:
            break;
    }

    Notifier::get().update(delta_ms);
    RenderInfo::get().update(delta_ms, Options::buildRenderInfoFrame(UiConfig::get().renderInfoText(), UiConfig::get().renderInfoShadow()));
}

void LogoScene::render() {
    constexpr std::uint32_t BLACK_ARGB = 0xFF000000U;
    Screen::get().fillRect(0, 0, GameCanvas::WIDTH, GameCanvas::HEIGHT, BLACK_ARGB);

    // BLACK_INTRO i BLACK_OUTRO no pinten logo: només el negre del
    // fillRect d'aquí dalt. La resta de fases sí.
    const bool SHOW_LOGO = phase_ != Phase::BLACK_INTRO && phase_ != Phase::BLACK_OUTRO;
    if (logo_ && SHOW_LOGO) {
        const int X = (GameCanvas::WIDTH - logo_->getWidth()) / 2;
        const int Y = (GameCanvas::HEIGHT - logo_->getHeight()) / 2;
        if (phase_ == Phase::SCAN) {
            // Revelat CRT + glitch tail: la pròpia ScanReveal s'encarrega
            // del blit fila a fila, de la banda lluminosa, dels glitches,
            // del flash final i dels bursts del tail.
            scan_.render(*logo_, X, Y);
        } else {
            // HOLD_SILENT, HOLD_MUSIC, FADE_OUT: render normal, el logo
            // ja està a pantalla complet i estable.
            logo_->render(X, Y);
        }
    }

    Notifier::get().render();
    // Capa de fosa: només pinta durant FADE_OUT (alpha creixent). En
    // BLACK_OUTRO ja deixem la pantalla negra del fillRect, així que no
    // cal ni que `fade_` segueixi viu.
    fade_.render();
    RenderInfo::get().render();
    Screen::get().present();
}