jaildesigner-jailgames/coffee_crisis_arcade_edition
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 13 Wiki Activity
Files
2bc28d47cd43bf6b8fef4059b59964073c0146bc
coffee_crisis_arcade_edition/source/ui/service_menu.cpp
Sergio 41e3fd1d8d iwyu 
clang-tidy
clang-format
2025-08-10 22:01:18 +02:00

647 lines
22 KiB
C++
Raw Blame History

#include "ui/service_menu.h"
#include "audio.h" // Para Audio
#include "define_buttons.h" // Para DefineButtons
#include "difficulty.h" // Para getCodeFromName, getNameFromCode
#include "input.h" // Para Input
#include "input_types.h" // Para InputAction
#include "lang.h" // Para getText, getCodeFromName, getNameFromCode
#include "menu_option.h" // Para MenuOption, ActionOption, BoolOption, ListOption, FolderOption, IntOption, ActionListOption
#include "menu_renderer.h" // Para MenuRenderer
#include "options.h" // Para GamepadManager, gamepad_manager, PendingChanges, Video, pending_changes, video, Audio, Gamepad, Settings, audio, checkPendingChanges, settings, Window, getPlayerWhoUsesKeyboard, playerIdToString, stringToPlayerId, window, Keyboard, Music, Sound, keyboard
#include "param.h" // Para Param, param, ParamGame, ParamServiceMenu
#include "player.h" // Para Player
#include "resource.h" // Para Resource
#include "screen.h" // Para Screen
#include "section.hpp" // Para Name, name, Options, options
#include "ui/ui_message.h" // Para UIMessage
#include "utils.h" // Para Zone
// Singleton
ServiceMenu *ServiceMenu::instance = nullptr;
void ServiceMenu::init() { ServiceMenu::instance = new ServiceMenu(); }
void ServiceMenu::destroy() { delete ServiceMenu::instance; }
auto ServiceMenu::get() -> ServiceMenu * { return ServiceMenu::instance; }
// Constructor
ServiceMenu::ServiceMenu()
: current_settings_group_(SettingsGroup::MAIN),
previous_settings_group_(current_settings_group_) {
auto element_text = Resource::get()->getText("04b_25_flat");
auto title_text = Resource::get()->getText("04b_25_flat_2x");
// El renderer ahora se inicializa con su configuración
renderer_ = std::make_unique<MenuRenderer>(this, element_text, title_text);
restart_message_ui_ = std::make_unique<UIMessage>(element_text, Lang::getText("[SERVICE_MENU] NEED_RESTART_MESSAGE"), param.service_menu.title_color);
define_buttons_ = std::make_unique<DefineButtons>();
reset();
}
void ServiceMenu::toggle() {
if (define_buttons_ && define_buttons_->isEnabled()) {
return;
}
if (isAnimating() && !define_buttons_->isEnabled()) {
return;
}
playBackSound();
if (!enabled_) { // Si está cerrado, abrir
reset();
Options::gamepad_manager.assignAndLinkGamepads();
renderer_->show(this);
setEnabledInternal(true);
} else { // Si está abierto, cerrar
renderer_->hide();
setEnabledInternal(false);
}
}
void ServiceMenu::render() {
// Condición corregida: renderiza si está habilitado O si se está animando
if (enabled_ || isAnimating()) {
renderer_->render(this);
} else {
return; // Si no está ni habilitado ni animándose, no dibujes nada.
}
// El mensaje de reinicio y otros elementos solo deben aparecer si está completamente visible,
// no durante la animación.
if (enabled_ && !isAnimating()) {
const float MSG_X = param.game.game_area.center_x;
const float MSG_Y = renderer_->getRect().y + 39.0F;
restart_message_ui_->setPosition(MSG_X, MSG_Y);
restart_message_ui_->render();
if (define_buttons_ && define_buttons_->isEnabled()) {
define_buttons_->render();
}
}
}
void ServiceMenu::update() {
// El renderer siempre se actualiza para manejar sus animaciones
renderer_->update(this);
if (!enabled_) {
return;
}
// Lógica de actualización del mensaje de reinicio y botones
bool now_pending = Options::pending_changes.has_pending_changes;
if (now_pending != last_pending_changes_) {
now_pending ? restart_message_ui_->show() : restart_message_ui_->hide();
last_pending_changes_ = now_pending;
}
restart_message_ui_->update();
if (define_buttons_) {
define_buttons_->update();
if (define_buttons_->isEnabled() && define_buttons_->isReadyToClose()) {
define_buttons_->disable();
}
}
}
void ServiceMenu::reset() {
selected_ = 0;
main_menu_selected_ = 0;
current_settings_group_ = SettingsGroup::MAIN;
previous_settings_group_ = SettingsGroup::MAIN;
initializeOptions();
updateMenu();
renderer_->setLayout(this);
}
void ServiceMenu::moveBack() {
// Si estamos en una subpantalla, no llamamos a toggle
if (current_settings_group_ != SettingsGroup::MAIN) {
playBackSound();
current_settings_group_ = previous_settings_group_;
selected_ = (current_settings_group_ == SettingsGroup::MAIN) ? main_menu_selected_ : 0;
updateMenu();
return;
}
// Si estamos en la pantalla principal, llamamos a toggle() para cerrar con animación.
// toggle() ya reproduce el sonido, por lo que no es necesario aquí.
toggle();
}
// --- Lógica de Navegación ---
void ServiceMenu::setSelectorUp() {
if (display_options_.empty()) {
return;
}
selected_ = (selected_ > 0) ? selected_ - 1 : display_options_.size() - 1;
playMoveSound();
}
void ServiceMenu::setSelectorDown() {
if (display_options_.empty()) {
return;
}
selected_ = (selected_ + 1) % display_options_.size();
playMoveSound();
}
void ServiceMenu::adjustOption(bool adjust_up) {
if (display_options_.empty()) {
return;
}
auto &selected_option = display_options_.at(selected_);
if (selected_option->getBehavior() == MenuOption::Behavior::ADJUST) {
selected_option->adjustValue(adjust_up);
applySettings();
playAdjustSound();
}
}
void ServiceMenu::selectOption() {
if (display_options_.empty()) {
return;
}
if (current_settings_group_ == SettingsGroup::MAIN) {
main_menu_selected_ = selected_;
}
auto *selected_option = display_options_.at(selected_);
if (selected_option == nullptr) {
// This shouldn't happen in normal operation, but protects against null pointer
return;
}
if (auto *folder = dynamic_cast<FolderOption *>(selected_option)) {
previous_settings_group_ = current_settings_group_;
current_settings_group_ = folder->getTargetGroup();
selected_ = 0;
updateMenu();
} else if (selected_option->getBehavior() == MenuOption::Behavior::SELECT or selected_option->getBehavior() == MenuOption::Behavior::BOTH) {
selected_option->executeAction();
}
playSelectSound();
}
// --- Lógica Interna ---
void ServiceMenu::updateDisplayOptions() {
display_options_.clear();
for (auto &option : options_) {
if (option->getGroup() == current_settings_group_ && !option->isHidden()) {
display_options_.push_back(option.get());
}
}
updateOptionPairs();
}
void ServiceMenu::updateOptionPairs() {
option_pairs_.clear();
for (const auto &option : display_options_) {
option_pairs_.emplace_back(option->getCaption(), option->getValueAsString());
}
}
void ServiceMenu::updateMenu() {
title_ = settingsGroupToString(current_settings_group_);
adjustListValues();
// Actualiza las opciones visibles
updateDisplayOptions();
// Notifica al renderer del cambio de layout
renderer_->onLayoutChanged(this);
}
void ServiceMenu::applySettings() {
if (current_settings_group_ == SettingsGroup::CONTROLS) {
applyControlsSettings();
}
if (current_settings_group_ == SettingsGroup::VIDEO) {
applyVideoSettings();
}
if (current_settings_group_ == SettingsGroup::AUDIO) {
applyAudioSettings();
}
if (current_settings_group_ == SettingsGroup::SETTINGS) {
applySettingsSettings();
}
// Actualiza los valores de las opciones
updateOptionPairs();
}
void ServiceMenu::applyControlsSettings() {}
void ServiceMenu::applyVideoSettings() {
Screen::get()->applySettings();
setHiddenOptions();
}
void ServiceMenu::applyAudioSettings() {
Audio::get()->applySettings();
}
void ServiceMenu::applySettingsSettings() {
setHiddenOptions();
}
auto ServiceMenu::getOptionByCaption(const std::string &caption) const -> MenuOption * {
for (const auto &option : options_) {
if (option->getCaption() == caption) {
return option.get();
}
}
return nullptr;
}
// --- Getters y otros ---
auto ServiceMenu::getCurrentGroupAlignment() const -> ServiceMenu::GroupAlignment {
switch (current_settings_group_) {
case SettingsGroup::CONTROLS:
case SettingsGroup::VIDEO:
case SettingsGroup::AUDIO:
case SettingsGroup::SETTINGS:
return GroupAlignment::LEFT;
default:
return GroupAlignment::CENTERED;
}
}
auto ServiceMenu::countOptionsInGroup(SettingsGroup group) const -> size_t {
size_t count = 0;
for (const auto &option : options_) {
if (option->getGroup() == group && !option->isHidden()) {
count++;
}
}
return count;
}
// Inicializa todas las opciones del menú
void ServiceMenu::initializeOptions() {
options_.clear();
// CONTROLS - Usando ActionListOption para mandos
options_.push_back(std::make_unique<ActionListOption>(
Lang::getText("[SERVICE_MENU] CONTROLLER1"),
SettingsGroup::CONTROLS,
Input::get()->getControllerNames(),
[]() {
return Options::gamepad_manager.getGamepad(Player::Id::PLAYER1).name;
},
[](const std::string &val) {
Options::gamepad_manager.assignGamepadToPlayer(Player::Id::PLAYER1, Input::get()->getGamepadByName(val), val);
},
[this]() {
// Acción: configurar botones del mando del jugador 1
auto *gamepad = &Options::gamepad_manager.getGamepad(Player::Id::PLAYER1);
if ((gamepad != nullptr) && gamepad->instance) {
define_buttons_->enable(gamepad);
}
}));
options_.push_back(std::make_unique<ActionListOption>(
Lang::getText("[SERVICE_MENU] CONTROLLER2"),
SettingsGroup::CONTROLS,
Input::get()->getControllerNames(),
[]() {
return Options::gamepad_manager.getGamepad(Player::Id::PLAYER2).name;
},
[](const std::string &val) {
Options::gamepad_manager.assignGamepadToPlayer(Player::Id::PLAYER2, Input::get()->getGamepadByName(val), val);
},
[this]() {
// Acción: configurar botones del mando del jugador 2
auto *gamepad = &Options::gamepad_manager.getGamepad(Player::Id::PLAYER2);
if ((gamepad != nullptr) && gamepad->instance) {
define_buttons_->enable(gamepad);
}
}));
// CONTROLS - Opción para teclado (solo lista, sin acción)
options_.push_back(std::make_unique<ListOption>(
Lang::getText("[SERVICE_MENU] KEYBOARD"),
SettingsGroup::CONTROLS,
std::vector<std::string>{
Lang::getText("[SERVICE_MENU] PLAYER1"),
Lang::getText("[SERVICE_MENU] PLAYER2")},
[]() {
// Devolver el jugador actual asignado al teclado
return Options::playerIdToString(Options::getPlayerWhoUsesKeyboard());
},
[](const std::string &val) {
// Asignar el teclado al jugador seleccionado
Options::keyboard.assignTo(Options::stringToPlayerId(val));
}));
// CONTROLS - Acción para intercambiar mandos
options_.push_back(std::make_unique<ActionOption>(
Lang::getText("[SERVICE_MENU] SWAP_CONTROLLERS"),
SettingsGroup::CONTROLS,
[this]() {
Options::gamepad_manager.swapPlayers();
adjustListValues(); // Sincroniza el valor de las opciones de lista (como MANDO1) con los datos reales
updateOptionPairs(); // Actualiza los pares de texto <opción, valor> que se van a dibujar
}));
// VIDEO
options_.push_back(std::make_unique<BoolOption>(
Lang::getText("[SERVICE_MENU] FULLSCREEN"),
SettingsGroup::VIDEO,
&Options::video.fullscreen));
options_.push_back(std::make_unique<IntOption>(
Lang::getText("[SERVICE_MENU] WINDOW_SIZE"),
SettingsGroup::VIDEO,
&Options::window.zoom,
1,
Options::window.max_zoom,
1));
options_.push_back(std::make_unique<BoolOption>(
Lang::getText("[SERVICE_MENU] SHADERS"),
SettingsGroup::VIDEO,
&Options::video.shaders));
options_.push_back(std::make_unique<BoolOption>(
Lang::getText("[SERVICE_MENU] VSYNC"),
SettingsGroup::VIDEO,
&Options::video.vsync));
options_.push_back(std::make_unique<BoolOption>(
Lang::getText("[SERVICE_MENU] INTEGER_SCALE"),
SettingsGroup::VIDEO,
&Options::video.integer_scale));
// AUDIO
options_.push_back(std::make_unique<BoolOption>(
Lang::getText("[SERVICE_MENU] AUDIO"),
SettingsGroup::AUDIO,
&Options::audio.enabled));
options_.push_back(std::make_unique<IntOption>(
Lang::getText("[SERVICE_MENU] MAIN_VOLUME"),
SettingsGroup::AUDIO,
&Options::audio.volume,
0,
100,
5));
options_.push_back(std::make_unique<IntOption>(
Lang::getText("[SERVICE_MENU] MUSIC_VOLUME"),
SettingsGroup::AUDIO,
&Options::audio.music.volume,
0,
100,
5));
options_.push_back(std::make_unique<IntOption>(
Lang::getText("[SERVICE_MENU] SFX_VOLUME"),
SettingsGroup::AUDIO,
&Options::audio.sound.volume,
0,
100,
5));
// SETTINGS
options_.push_back(std::make_unique<BoolOption>(
Lang::getText("[SERVICE_MENU] AUTOFIRE"),
SettingsGroup::SETTINGS,
&Options::settings.autofire));
options_.push_back(std::make_unique<ListOption>(
Lang::getText("[SERVICE_MENU] LANGUAGE"),
SettingsGroup::SETTINGS,
std::vector<std::string>{
Lang::getText("[SERVICE_MENU] LANG_ES"),
Lang::getText("[SERVICE_MENU] LANG_BA"),
Lang::getText("[SERVICE_MENU] LANG_EN")},
[]() {
return Lang::getNameFromCode(Options::pending_changes.new_language);
},
[](const std::string &val) {
Options::pending_changes.new_language = Lang::getCodeFromName(val);
Options::checkPendingChanges();
}));
options_.push_back(std::make_unique<ListOption>(
Lang::getText("[SERVICE_MENU] DIFFICULTY"),
SettingsGroup::SETTINGS,
std::vector<std::string>{
Lang::getText("[SERVICE_MENU] EASY"),
Lang::getText("[SERVICE_MENU] NORMAL"),
Lang::getText("[SERVICE_MENU] HARD")},
[]() {
return Difficulty::getNameFromCode(Options::pending_changes.new_difficulty);
},
[](const std::string &val) {
Options::pending_changes.new_difficulty = Difficulty::getCodeFromName(val);
Options::checkPendingChanges();
}));
options_.push_back(std::make_unique<BoolOption>(
Lang::getText("[SERVICE_MENU] ENABLE_SHUTDOWN"),
SettingsGroup::SETTINGS,
&Options::settings.shutdown_enabled));
// SYSTEM
options_.push_back(std::make_unique<ActionOption>(
Lang::getText("[SERVICE_MENU] RESET"),
SettingsGroup::SYSTEM,
[this]() {
Section::name = Section::Name::RESET;
toggle();
}));
options_.push_back(std::make_unique<ActionOption>(
Lang::getText("[SERVICE_MENU] QUIT"),
SettingsGroup::SYSTEM,
[]() {
Section::name = Section::Name::QUIT;
Section::options = Section::Options::NONE;
}));
options_.push_back(std::make_unique<ActionOption>(
Lang::getText("[SERVICE_MENU] SHUTDOWN"),
SettingsGroup::SYSTEM,
[]() {
Section::name = Section::Name::QUIT;
Section::options = Section::Options::SHUTDOWN;
},
!Options::settings.shutdown_enabled));
// MAIN MENU
options_.push_back(std::make_unique<FolderOption>(
Lang::getText("[SERVICE_MENU] CONTROLS"),
SettingsGroup::MAIN,
SettingsGroup::CONTROLS));
options_.push_back(std::make_unique<FolderOption>(
Lang::getText("[SERVICE_MENU] VIDEO"),
SettingsGroup::MAIN,
SettingsGroup::VIDEO));
options_.push_back(std::make_unique<FolderOption>(
Lang::getText("[SERVICE_MENU] AUDIO"),
SettingsGroup::MAIN,
SettingsGroup::AUDIO));
options_.push_back(std::make_unique<FolderOption>(
Lang::getText("[SERVICE_MENU] SETTINGS"),
SettingsGroup::MAIN,
SettingsGroup::SETTINGS));
options_.push_back(std::make_unique<FolderOption>(
Lang::getText("[SERVICE_MENU] SYSTEM"),
SettingsGroup::MAIN,
SettingsGroup::SYSTEM));
// Oculta opciones según configuración
setHiddenOptions();
}
// Sincroniza los valores de las opciones tipo lista
void ServiceMenu::adjustListValues() {
for (auto &option : options_) {
if (auto *list_option = dynamic_cast<ListOption *>(option.get())) {
list_option->sync();
}
}
}
// Reproduce el sonido de navegación del menú
void ServiceMenu::playAdjustSound() { Audio::get()->playSound("service_menu_adjust.wav", Audio::Group::INTERFACE); }
void ServiceMenu::playMoveSound() { Audio::get()->playSound("service_menu_move.wav", Audio::Group::INTERFACE); }
void ServiceMenu::playSelectSound() { Audio::get()->playSound("service_menu_select.wav", Audio::Group::INTERFACE); }
void ServiceMenu::playBackSound() { Audio::get()->playSound("service_menu_select.wav", Audio::Group::INTERFACE); }
// Devuelve el nombre del grupo como string para el título
auto ServiceMenu::settingsGroupToString(SettingsGroup group) -> std::string {
switch (group) {
case SettingsGroup::MAIN:
return Lang::getText("[SERVICE_MENU] TITLE");
case SettingsGroup::CONTROLS:
return Lang::getText("[SERVICE_MENU] CONTROLS");
case SettingsGroup::VIDEO:
return Lang::getText("[SERVICE_MENU] VIDEO");
case SettingsGroup::AUDIO:
return Lang::getText("[SERVICE_MENU] AUDIO");
case SettingsGroup::SETTINGS:
return Lang::getText("[SERVICE_MENU] SETTINGS");
case SettingsGroup::SYSTEM:
return Lang::getText("[SERVICE_MENU] SYSTEM");
default:
return Lang::getText("[SERVICE_MENU] TITLE");
}
}
// Establece el estado de oculto de ciertas opciones
void ServiceMenu::setHiddenOptions() {
{
auto *option = getOptionByCaption(Lang::getText("[SERVICE_MENU] WINDOW_SIZE"));
if (option != nullptr) {
option->setHidden(Options::video.fullscreen);
}
}
{
auto *option = getOptionByCaption(Lang::getText("[SERVICE_MENU] SHUTDOWN"));
if (option != nullptr) {
option->setHidden(!Options::settings.shutdown_enabled);
}
}
updateMenu(); // El menú debe refrescarse si algo se oculta
}
void ServiceMenu::handleEvent(const SDL_Event &event) {
if (!enabled_) {
return;
}
// Si DefineButtons está activo, que maneje todos los eventos
if (define_buttons_ && define_buttons_->isEnabled()) {
define_buttons_->handleEvents(event);
// return; // No procesar otros eventos mientras DefineButtons está activo
}
}
auto ServiceMenu::checkInput() -> bool {
// --- Guardas ---
// No procesar input si el menú no está habilitado, si se está animando o si se definen botones
if (!enabled_ || isAnimating() || (define_buttons_ && define_buttons_->isEnabled())) {
return false;
}
static auto *input_ = Input::get();
using Action = Input::Action;
const std::vector<std::pair<Action, std::function<void()>>> ACTIONS = {
{Action::UP, [this]() { setSelectorUp(); }},
{Action::DOWN, [this]() { setSelectorDown(); }},
{Action::RIGHT, [this]() { adjustOption(true); }},
{Action::LEFT, [this]() { adjustOption(false); }},
{Action::SM_SELECT, [this]() { selectOption(); }},
{Action::SM_BACK, [this]() { moveBack(); }},
};
// Teclado
for (const auto &[action, func] : ACTIONS) {
if (input_->checkAction(action, Input::DO_NOT_ALLOW_REPEAT, Input::CHECK_KEYBOARD)) {
func();
return true;
}
}
// Mandos
for (auto gamepad : input_->getGamepads()) {
for (const auto &[action, func] : ACTIONS) {
if (input_->checkAction(action, Input::DO_NOT_ALLOW_REPEAT, Input::DO_NOT_CHECK_KEYBOARD, gamepad)) {
func();
return true;
}
}
}
return false;
}
// --- Nuevo Getter ---
auto ServiceMenu::isAnimating() const -> bool {
return renderer_ && renderer_->isAnimating();
}
auto ServiceMenu::isDefiningButtons() const -> bool {
return define_buttons_ && define_buttons_->isEnabled();
}
void ServiceMenu::refresh() {
// Este método está diseñado para ser llamado desde fuera, por ejemplo,
// cuando un mando se conecta o desconecta mientras el menú está abierto.
// La función updateMenu() es la forma más completa de refrescar, ya que
// sincroniza los valores, actualiza la lista de opciones visibles y notifica
// al renderer de cualquier cambio de layout que pueda haber ocurrido.
updateMenu();
}
// Método para registrar callback
void ServiceMenu::setStateChangeCallback(StateChangeCallback callback) {
state_change_callback_ = callback;
}
// Método interno que cambia estado y notifica
void ServiceMenu::setEnabledInternal(bool enabled) {
if (enabled_ != enabled) { // Solo si realmente cambia
enabled_ = enabled;
// Notifica el cambio si hay callback registrado
if (state_change_callback_) {
state_change_callback_(enabled_);
}
}
}
Reference in New Issue View Git Blame Copy Permalink