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

#include "game/scenes/title_scene.hpp"

#include <SDL3/SDL.h>

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

#include "core/audio/audio.hpp"
#include "core/input/gamepad_bindings.hpp"
#include "core/input/gamepad_manager.hpp"
#include "core/input/global_inputs.hpp"
#include "core/locale/locale.hpp"
#include "core/rendering/notifier.hpp"
#include "core/rendering/render_info.hpp"
#include "core/rendering/screen.hpp"
#include "core/rendering/surface.hpp"
#include "core/rendering/text.hpp"
#include "core/resources/resource_cache.hpp"
#include "core/system/event_buffer.hpp"
#include "core/ui/ui_config.hpp"
#include "game/options.hpp"
#include "game/scenes/scene_flow.hpp"
#include "utils/defaults.hpp"
#include "utils/defines.hpp"

namespace {

    // TODO: migrar a un logger unificat quan es decideixi (veure INC-03 a
    // docs/audit-core-rendering.md).
    const char* const SCENE_NAME = "TITLE";

    // Textos hardcodejats fins que tinguem artwork. Quan apareguen com
    // a sprites, aquesta secció desapareix sencera.
    const char* const TITLE_LINE_1 = "Aventures en Egipte";
    const char* const TITLE_LINE_2 = "A R C A D E";

    constexpr int TITLE_Y_PERCENT = 25;
    constexpr int PROMPT_Y_PERCENT = 60;
    constexpr int COPYRIGHT_Y_PERCENT = 90;
    constexpr int LOGO_GAP_PX = 2;  // Separació vertical entre el minilogo i el text de copyright.

    // Detecta una pulsació de START dins el frame actual per al jugador
    // indicat. Combina events de teclat (scancode hardcoded a Defaults::
    // KeysGame[P2]) i events de gamepad (botó remapejable via
    // GamepadBindings, lligat al pad assignat al jugador via Options).
    auto pressedStart(int player_id) -> bool {
        const SDL_Scancode KB = (player_id == 0) ? Defaults::KeysGame::START : Defaults::KeysGameP2::START;
        SDL_Gamepad* pad = GamepadManager::get().getForPlayer(player_id);
        const SDL_JoystickID PAD_ID = (pad != nullptr) ? SDL_GetGamepadID(pad) : 0;
        const auto& slot = (player_id == 0) ? Options::controls().gamepad_p1
                                            : Options::controls().gamepad_p2;
        const int START_BTN = GamepadBindings::get().getButton(slot.name, slot.path, GamepadBindings::Action::START);

        return std::ranges::any_of(EventBuffer::events, [&](const SDL_Event& ev) {
            if (ev.type == SDL_EVENT_KEY_DOWN && ev.key.scancode == KB) { return true; }
            if (ev.type == SDL_EVENT_GAMEPAD_BUTTON_DOWN && pad != nullptr && ev.gbutton.which == PAD_ID && static_cast<int>(ev.gbutton.button) == START_BTN) {
                return true;
            }
            return false;
        });
    }

    // Separació vertical entre la primera i segona línia del títol. Una
    // alçada de línia és l'opció més llegible al canvas de 240 px sense
    // entrar a configuració extra; si demà cal afinar-ho, mou-se a
    // ui.yaml.
    [[nodiscard]] auto titleLineGap(const Text& font) -> int {
        return font.getLineHeight();
    }

    // Reproducció del so de START. Centralitzat ací per disparar-lo des
    // dels punts on una pulsació té efecte real (entrada a STARTING o
    // upgrade a BOTH); l'attract timeout no l'ha de tocar.
    void playStartSound() {
        if (auto* audio = Audio::get(); audio != nullptr) {
            audio->playSound(UiConfig::get().playerStartSound(), Audio::Group::INTERFACE);
        }
    }

}  // namespace

TitleScene::TitleScene(std::shared_ptr<Text> display_font, std::shared_ptr<Text> condensed_font, std::shared_ptr<Surface> background, std::shared_ptr<Surface> mini_logo)
    : display_font_(std::move(display_font)),
      condensed_font_(std::move(condensed_font)),
      background_(std::move(background)),
      mini_logo_(std::move(mini_logo)),
      timer_ms_(UiConfig::get().titleDurationMs()) {
    std::cout << "[scene] " << SCENE_NAME << " start\n";
    const auto& hh = UiConfig::get().titleHeatHaze();
    if (hh.enabled) {
        heat_haze_.emplace(Effects::HeatHaze::Params{
            .amplitude_px = hh.amplitude_px,
            .wavelength_px = hh.wavelength_px,
            .speed_hz = hh.speed_hz,
        });
    }
    fade_out_.emplace(Transitions::Mosaic::Params{
        .max_block_size = UiConfig::get().titleFadeOutMaxBlock(),
    });
    attract_fade_.emplace();

    // Música de fons en bucle. Es preloda al Director, així que la
    // primera crida és immediata. El fade-out arrenca en entrar a
    // STARTING (vore enterStarting); en ATTRACT_OUT NO es toca, la
    // música segueix sonant cap a LOGO.
    if (auto* audio = Audio::get(); audio != nullptr) {
        audio->playMusic("title.ogg", -1);
    }
}

TitleScene::~TitleScene() = default;

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

    if (heat_haze_) { heat_haze_->tick(delta_ms); }

    // Comptador del parpadeig: avança sempre amb `delta_ms` cru. La
    // lectura (cicle/visible) la decideix `render()` segons la fase:
    // IDLE usa visible_ms / hidden_ms del yaml (asimètric, 80/20 per
    // defecte); STARTING usa un cicle simètric 50/50 amb període
    // `starting_blink_period_ms`.
    blink_elapsed_ms_ += delta_ms;

    const bool P1_START = pressedStart(0);
    const bool P2_START = pressedStart(1);

    switch (phase_) {
        case Phase::IDLE:
            tickIdle(delta_ms, P1_START, P2_START);
            break;
        case Phase::STARTING:
            tickStarting(delta_ms, P1_START, P2_START);
            break;
        case Phase::ATTRACT_OUT:
            tickAttract(delta_ms);
            break;
    }

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

void TitleScene::enterStarting(DebugConfig::StartingPlayers players) {
    phase_ = Phase::STARTING;
    pending_players_ = players;
    starting_timer_ms_ = UiConfig::get().titleStartingMs();
    // Resetem el comptador del parpadeig perquè el primer frame de
    // STARTING comenci visible — sense això, el modulus amb el nou
    // període podria caure mig cicle i donar un primer "off" estrany.
    blink_elapsed_ms_ = 0;
    // Fade-out de la música. Si l'altre jugador prem START i el timer
    // es reseteja, no rearranquem la música: es manté la fosa iniciada
    // ací (consistent amb el fade visual, que tampoc es reverteix).
    if (auto* audio = Audio::get(); audio != nullptr) {
        audio->fadeOutMusic(UiConfig::get().titleMusicFadeOutMs());
    }
    std::cout << "[scene] " << SCENE_NAME << " STARTING (players=" << DebugConfig::toString(players) << ")\n";
}

void TitleScene::tickIdle(int delta_ms, bool p1_start, bool p2_start) {
    timer_ms_ -= delta_ms;
    if (p1_start) {
        playStartSound();
        enterStarting(DebugConfig::StartingPlayers::P1);
    } else if (p2_start) {
        playStartSound();
        enterStarting(DebugConfig::StartingPlayers::P2);
    } else if (timer_ms_ <= 0) {
        // Attract timeout: ningú ha premut. Sortida silenciosa cap a
        // LOGO amb fade-to-black; música i parpadeig intactes.
        enterAttract();
    }
}

void TitleScene::tickStarting(int delta_ms, bool p1_start, bool p2_start) {
    starting_timer_ms_ -= delta_ms;
    // Si l'altre jugador prem START dins de la finestra (i el fade
    // encara no ha arrencat), pugem a BOTH i resetegem el comptador.
    // Una vegada el fade ja està actiu, ignorem pulsacions per no
    // saltar visualment la transició.
    const bool OTHER_PRESSED =
        (pending_players_ == DebugConfig::StartingPlayers::P1 && p2_start) ||
        (pending_players_ == DebugConfig::StartingPlayers::P2 && p1_start);
    const bool FADE_LOCKED = fade_out_ && (fade_out_->isActive() || fade_out_->isFinished());
    if (OTHER_PRESSED && !FADE_LOCKED) {
        playStartSound();
        pending_players_ = DebugConfig::StartingPlayers::BOTH;
        starting_timer_ms_ = UiConfig::get().titleStartingMs();
    }

    // Arrenca el fade quan al comptador li queden <= fade_out_ms, i
    // només una vegada (ni en repeticions ni si l'altre jugador ha
    // resetejat el timer).
    const int FADE_MS = UiConfig::get().titleFadeOutMs();
    if (fade_out_ && !fade_out_->isActive() && !fade_out_->isFinished() && starting_timer_ms_ <= FADE_MS && FADE_MS > 0) {
        fade_out_->begin(FADE_MS);
    }
    if (fade_out_ && fade_out_->isActive()) { fade_out_->tick(delta_ms); }

    if (starting_timer_ms_ <= 0) {
        advanceToIntro(pending_players_);
    }
}

void TitleScene::tickAttract(int delta_ms) {
    // Sortida d'attract: només avancem el fade-to-black. Quan s'acaba
    // demanem transició a LOGO. Cap input ni música ni canvi de
    // freqüència de parpadeig — el text "press start" segueix amb el
    // cicle d'IDLE per damunt del fade.
    if (!attract_fade_) { return; }
    attract_fade_->tick(delta_ms);
    if (attract_fade_->isFinished()) {
        advanceToLogo();
    }
}

void TitleScene::enterAttract() {
    phase_ = Phase::ATTRACT_OUT;
    if (attract_fade_) {
        attract_fade_->begin(UiConfig::get().titleAttractFadeToBlackMs());
    }
    std::cout << "[scene] " << SCENE_NAME << " ATTRACT_OUT\n";
}

void TitleScene::advanceToIntro(DebugConfig::StartingPlayers players) {
    exit_request_ = ExitRequest{
        .next = SceneId::INTRO,
        .params = IntroParams{.starting_players = players},
    };
}

void TitleScene::advanceToLogo() {
    exit_request_ = ExitRequest{
        .next = SceneId::LOGO,
        .params = LogoParams{},
    };
}

void TitleScene::render() {
    const auto& ui_config = UiConfig::get();
    const auto& palette = Resource::Cache::get().getPalette("ui");

    // Fons: la imatge si està disponible (cobreix tot el canvas amb la
    // seua paleta nadiua), opcionalment amb heat-haze; en cas contrari,
    // color pla de la paleta UI com a fallback defensiu.
    if (background_) {
        if (heat_haze_) {
            heat_haze_->render(*background_, 0, 0);
        } else {
            background_->render(0, 0);
        }
    } else {
        Screen::get().fillRect(0, 0, GameCanvas::WIDTH, GameCanvas::HEIGHT, palette[ui_config.titleBgColor()]);
    }

    const Uint8 TEXT_COLOR = ui_config.titleTextColor();
    const Uint8 OUTLINE_COLOR = ui_config.titleCopyrightColor();
    constexpr Uint8 OUTLINE_DIST = 1;
    constexpr Uint8 STROKE4 = Text::CENTER_FLAG | Text::COLOR_FLAG | Text::STROKE4_FLAG;

    if (display_font_) {
        const int TITLE_Y = (GameCanvas::HEIGHT * TITLE_Y_PERCENT) / 100;
        display_font_->writeDX(STROKE4,
            GameCanvas::CENTER_X,
            TITLE_Y,
            TITLE_LINE_1,
            display_font_->getDefaultKerning(),
            TEXT_COLOR,
            OUTLINE_DIST,
            OUTLINE_COLOR);
        display_font_->writeDX(STROKE4,
            GameCanvas::CENTER_X,
            TITLE_Y + titleLineGap(*display_font_),
            TITLE_LINE_2,
            display_font_->getDefaultKerning(),
            TEXT_COLOR,
            OUTLINE_DIST,
            OUTLINE_COLOR);
    }

    if (condensed_font_) {
        // Cicle de parpadeig: a IDLE pren visible_ms+hidden_ms del yaml
        // (asimètric, 80/20 per defecte); a STARTING commuta a 50/50 amb
        // `starting_blink_period_ms` per donar feedback de "polsat".
        // Si el cicle val 0 (configuració degenerada), cau a "sempre visible".
        int cycle_ms = 0;
        int visible_ms = 0;
        if (phase_ == Phase::STARTING) {
            cycle_ms = std::max(0, ui_config.titleStartingBlinkPeriodMs());
            visible_ms = cycle_ms / 2;
        } else {
            visible_ms = std::max(0, ui_config.titleBlinkVisibleMs());
            cycle_ms = visible_ms + std::max(0, ui_config.titleBlinkHiddenMs());
        }
        const bool VISIBLE = (cycle_ms == 0) || ((blink_elapsed_ms_ % cycle_ms) < visible_ms);

        if (VISIBLE) {
            const int PROMPT_Y = (GameCanvas::HEIGHT * PROMPT_Y_PERCENT) / 100;
            condensed_font_->writeDX(STROKE4,
                GameCanvas::CENTER_X,
                PROMPT_Y,
                Locale::get().text("title.press_start"),
                condensed_font_->getDefaultKerning() - 1,
                TEXT_COLOR,
                OUTLINE_DIST,
                OUTLINE_COLOR);
        }
    }

    // Footer: minilogo centrat horitzontalment damunt del © de
    // copyright. El text va al 90% Y, el logo just damunt amb un petit
    // gap (LOGO_GAP_PX). Tots dos blocs són hardcodejats fins que
    // tinguem artwork final.
    if (condensed_font_) {
        const int COPY_Y = (GameCanvas::HEIGHT * COPYRIGHT_Y_PERCENT) / 100;
        if (mini_logo_) {
            const int LOGO_X = GameCanvas::CENTER_X - (mini_logo_->getWidth() / 2);
            const int LOGO_Y = COPY_Y - mini_logo_->getHeight() - LOGO_GAP_PX;
            mini_logo_->render(LOGO_X, LOGO_Y);
        }
        condensed_font_->writeDX(Text::CENTER_FLAG | Text::COLOR_FLAG,
            GameCanvas::CENTER_X,
            COPY_Y,
            "© 2026 JailDesigner",
            condensed_font_->getDefaultKerning() - 1,
            ui_config.titleCopyrightColor());
    }

    Notifier::get().render();

    // Capa de transició final segons la fase. Sempre cobreix l'escena
    // i el Notifier, mai el RenderInfo (overlay de debug, sempre
    // visible). STARTING usa mosaic dissolve; ATTRACT_OUT, fade-to-black
    // lineal (sense efecte chunky perquè la sortida silenciosa s'integre
    // amb la pista visual del LOGO).
    if (phase_ == Phase::ATTRACT_OUT && attract_fade_) {
        attract_fade_->render();
    } else if (fade_out_ && (fade_out_->isActive() || fade_out_->isFinished())) {
        fade_out_->render();
    }

    RenderInfo::get().render();
    Screen::get().present();
}