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/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 "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();
    }

}  // 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, SceneFactory next_factory)
    : display_font_(std::move(display_font)),
      condensed_font_(std::move(condensed_font)),
      background_(std::move(background)),
      mini_logo_(std::move(mini_logo)),
      next_factory_(std::move(next_factory)),
      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,
        });
    }
}

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

    // Avanç del comptador del parpadeig: durant STARTING, accelera per
    // `starting_blink_speedup` (típicament 2.0). Es manté en enter perquè
    // tota la lògica del cicle (visible_ms / hidden_ms) treballa amb int.
    const float BLINK_RATE = (phase_ == Phase::STARTING)
        ? UiConfig::get().titleStartingBlinkSpeedup()
        : 1.0F;
    blink_elapsed_ms_ += static_cast<int>(static_cast<float>(delta_ms) * BLINK_RATE);

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

    switch (phase_) {
        case Phase::IDLE: {
            timer_ms_ -= delta_ms;
            if (P1_START) {
                enterStarting(DebugConfig::StartingPlayers::P1);
            } else if (P2_START) {
                enterStarting(DebugConfig::StartingPlayers::P2);
            } else if (timer_ms_ <= 0) {
                // Attract: ningú ha premut. Saltem a la següent escena
                // amb BOTH per defecte. Demà, quan tinguem una DemoScene,
                // ací anirà la transició a demo en lloc de a intro.
                advanceTo(DebugConfig::StartingPlayers::BOTH);
            }
            break;
        }
        case Phase::STARTING: {
            starting_timer_ms_ -= delta_ms;
            // Si l'altre jugador prem START dins de la finestra, pugem
            // a BOTH i resetegem el comptador. Pulsacions repetides del
            // mateix jugador ja "starting" no fan res.
            const bool OTHER_PRESSED =
                (pending_players_ == DebugConfig::StartingPlayers::P1 && P2_START) ||
                (pending_players_ == DebugConfig::StartingPlayers::P2 && P1_START);
            if (OTHER_PRESSED) {
                pending_players_ = DebugConfig::StartingPlayers::BOTH;
                starting_timer_ms_ = UiConfig::get().titleStartingMs();
            }
            if (starting_timer_ms_ <= 0) {
                advanceTo(pending_players_);
            }
            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();
    std::cout << "[scene] " << SCENE_NAME << " STARTING (players=" << DebugConfig::toString(players) << ")\n";
}

void TitleScene::advanceTo(DebugConfig::StartingPlayers players) {
    if (next_factory_) {
        next_scene_ = next_factory_(players);
    }
}

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: visible_ms ON + hidden_ms OFF, repetint-se.
        // Si la suma val 0 (configuració degenerada), cau a "sempre visible".
        const int VISIBLE_MS = std::max(0, ui_config.titleBlinkVisibleMs());
        const int HIDDEN_MS = std::max(0, ui_config.titleBlinkHiddenMs());
        const int CYCLE_MS = VISIBLE_MS + HIDDEN_MS;
        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();
    RenderInfo::get().render();
    Screen::get().present();
}