// SPDX-License-Identifier: GPL-3.0-only #pragma once #include #include #include #include #include "ui/manager.hpp" #include "ui/desktop.hpp" #include "ui/preparation.hpp" #include "ui/save_load.hpp" #include "ui/stadium.hpp" #include "ui/matchday_results_screen.hpp" #include "ui/league_table.hpp" #include "ui/league_table_range_dialog.hpp" #include "ui/league_pairings.hpp" #include "ui/mailbox_screen.hpp" #include "ui/settings.hpp" #include "ui/advertising.hpp" #include "ui/friendly_match.hpp" #include "ui/national_friendly_ui.hpp" #include "ui/calendar.hpp" #include "ui/strengths.hpp" #include "ui/top_scorers.hpp" #include "ui/desk_records.hpp" #include "ui/opportunities.hpp" #include "ui/statistics_rankings.hpp" #include "ui/analytics.hpp" #include "ui/minute_statistics.hpp" #include "ui/transfer_history.hpp" #include "ui/contracts.hpp" #include "ui/outgoing_transfer.hpp" #include "ui/balance_plan.hpp" #include "ui/other_games.hpp" #include "ui/alltime_table.hpp" #include "ui/world_cup_statistics.hpp" #include "ui/finance_totals.hpp" #include "ui/series_records.hpp" #include "ui/environment.hpp" #include "ui/indoor_standings.hpp" #include "ui/achievements.hpp" namespace bmh::ui { // Value boundary for the future engine adapter. No RNG, RAM or save writes. struct NewCareerRequest { SetupOptions options; std::vector managers; }; struct InitializedManager { int slot = -1, master_club = -1, runtime_club = -1; }; struct CareerInitializationResult { DeskState desktop; std::vector managers; PreparationState preparation; }; enum class FlowRequest { none, load_game, manager_confirmed, new_career, kickoff, desk_action, end_session, submenu_opened, submenu_closed, contracts_closed, submenu_action, file_action, results_closed, mailbox_action, mailbox_closed, settings_action, settings_close, settings_file_action, friendly_action, national_friendly_selected, contract_action, advertising_action, environment_action, join_options, join_manager, join_cancel, league_pairings_action, strengths_action, top_scorers_action, balance_action, other_games_action, league_family_action, opportunities_action, statistics_menu_action, statistics_rankings_action, analytics_action, statistics_page_action, reschedule_action }; enum class StatisticsPageActionKind : uint8_t { close, alltime, world_cup }; struct StatisticsPageAction { DeskRequest owner{}; int page=-1; StatisticsPageActionKind kind=StatisticsPageActionKind::close; int nation=-1; bool relative=false; bool operator==(const StatisticsPageAction&) const = default; }; struct FlowResult { bool changed = false; FlowRequest request = FlowRequest::none; DeskRequest desk_action{}; PreparationRequest submenu_action{}; SaveLoadRequest file_action{}; MailboxActionRequest mailbox_action{}; MailboxCloseRequest mailbox_close{}; SettingsWriteRequest settings_action{}; uint64_t settings_owner_sequence = 0; FriendlyMatchRequest friendly_action{}; int national_friendly_opponent = -1; ContractRequest contract_action{}; AdvertisingRequest advertising_action{}; EnvironmentRequest environment_action{}; SetupOptions join_options{}; ManagerChoice join_manager{}; LeaguePairingsRequest league_pairings_action{}; StrengthsRequest strengths_action{}; TopScorersRequest top_scorers_action{}; OpportunitiesRequest opportunities_action{}; StatisticsMenuRequest statistics_menu_action{}; StatisticsRankingsRequest statistics_rankings_action{}; AnalyticsRequest analytics_action{}; StatisticsPageAction statistics_page_action{}; BalanceRequest balance_action{}; OtherGamesRequest other_games_action{}; LeagueFamilyRequest league_family_action{}; RescheduleAction reschedule_action{}; }; class StartupFlow { public: explicit StartupFlow(const std::filesystem::path& data, std::filesystem::path save_directory = {}) : data_(data), save_directory_(save_directory.empty() ? data : std::move(save_directory)), setup_(data) {} FlowResult click(int x, int y, bool right = false, bool double_click = false); FlowResult pointer_down(int x,int y,bool right=false); FlowResult process_timer_expired(int pointer_x = 0, int pointer_y = 0); bool timed_notice_open() const; FlowResult expire_timed_notice(); // The synchronous SDL question presenter consumes the original nation-click UP. // Call only after that modal has returned; right-DOWN close keeps its barrier. void acknowledge_national_friendly_modal_release() { national_friendly_release_barrier_=false; } FlowResult expire_stadium_tip(); bool in_stadium() const { return bool(stadium_); } bool in_pitch() const { return bool(pitch_); } std::optional pitch_formation_save_feedback(bool restored) const; FlowResult pitch_held_left(int x, int y, uint64_t source_ticks); void consume_orphaned_pitch_release(){pitch_release_barrier_=false;} const StadiumScreen* stadium() const { return stadium_.get(); } const TotoScreen* toto() const { return toto_.get(); } FlowResult hold(int x, int y, int milliseconds); FlowResult move_action(int x, int y); bool move(int x, int y) { return move_action(x, y).changed; } bool text(std::string_view value); bool key(std::string_view value) { return send_key(value).changed; } FlowResult send_key(std::string_view value); bool resume_manager_selection(SelectionContext context); void show_manager_join(std::vector existing, SelectionContext context); void resume_manager_join(SelectionContext context); void acknowledge_manager_join(CareerInitializationResult result); void reject_manager_join(std::string reason); const DeskRequest* join_origin() const { return joining_ ? &join_origin_ : nullptr; } const SetupOptions* pending_join_options() const { return join_options_pending_ ? &join_setup_->options() : nullptr; } const ManagerChoice* pending_join_manager() const { return join_choice_pending_ ? &join_choices_.back() : nullptr; } Image render() const; void load_reference(const std::filesystem::path& save, std::optional indoor = std::nullopt); void attach_initialized_career(CareerInitializationResult result); void acknowledge_desk(DeskState state); void reject_desk_action(std::string reason); void acknowledge_desk_notice(const DeskRequest& owner); void acknowledge_saved_game(DeskState desk, PreparationState preparation); // Complete an authenticated menu-layout operation while preserving the active career. void acknowledge_menu_layout(DeskState desk, PreparationState preparation); void reject_file_action(std::string reason); void attach_loaded_game(DeskState desk, PreparationState preparation); const SaveLoadRequest* pending_file() const { return save_load_ && save_load_->pending() ? &*save_load_->pending() : nullptr; } void attach_preparation_context(PreparationState state); void show_matchday_results(MatchdayResults results); bool in_results_view() const { return bool(matchday_results_); } bool in_settings() const { return bool(settings_ && !save_load_); } bool settings_readme_release_pending() const { return settings_readme_release_barrier_; } void show_league_tables(std::array tables, int initial_league); void show_family_league_tables(std::array tables, int initial_league, StrengthsIdentity identity, std::optional preparation = {}); void show_family_table_dispatch(std::array tables, int initial_league, StrengthsIdentity identity, std::optional dialog = {}, std::optional dialog_stage = {}, bool forecast_needs_present = false, std::optional preparation = {}, bool friendly_entry = false); // Accept a same-league internal selector operation without replacing its visible Table frame. void acknowledge_family_selector(const LeagueFamilyRequest& old_request, const StrengthsIdentity& accepted_identity); void begin_league_family(StrengthsIdentity identity); bool friendly_table_active() const { return friendly_table_active_; } void acknowledge_friendly_own_club(const LeagueFamilyRequest&,StrengthsIdentity); void complete_friendly_opponent_table(const LeagueFamilyRequest&,FriendlyMatchState,PreparationState); void close_league_family(const LeagueFamilyRequest&, PreparationState); void reject_league_family(std::string reason); const std::optional& league_family_identity() const { return league_family_identity_; } uint8_t league_family_child() const { return league_family_child_; } void replace_family_child(); const LeagueFamilyRequest* pending_league_family_action() const; FlowResult after_family_table_present(uint64_t absolute_source_units); FlowResult tick_family_table_source_units(uint64_t absolute_source_units); FlowResult cancel_family_table_from_source_event(); bool in_family_table_range_dialog() const { return bool(family_table_range_dialog_); } bool family_table_range_input_ready() const { return family_table_range_dialog_ && !family_table_dispatch_pending_ && family_table_range_dialog_->source_input_ready(); } bool in_toto_calculator() const { return toto_ && toto_->calculator_open(); } bool toto_calculator_input_ready() const { return toto_ && toto_->calculator_input_ready(); } FlowResult after_toto_present(uint64_t source_units); FlowResult tick_toto_source_units(uint64_t source_units); void show_league_pairings(LeaguePairingsState); void show_family_league_pairings(LeaguePairingsState, StrengthsIdentity); void acknowledge_league_pairings(LeaguePairingsState, std::optional family = {}); void close_league_pairings(PreparationState); void reject_league_pairings(std::string reason); bool in_league_pairings() const {return bool(league_pairings_);} bool in_family_table() const { return league_table_ && league_family_identity_ && league_family_child_==1; } FlowResult tick_league_pairings_source_seconds(uint64_t now); void mark_league_pairings_presented_source_seconds(uint64_t now); const LeaguePairingsScreen* league_pairings() const {return league_pairings_.get();} const LeaguePairingsRequest* pending_league_pairings() const { return league_pairings_&&league_pairings_->pending()?&*league_pairings_->pending():nullptr; } const LeagueFamilyRequest* pending_pairings_family_action() const { return league_pairings_&&league_pairings_->pending_family_action()?&*league_pairings_->pending_family_action():nullptr; } void show_mailbox(MailboxState state); // Source's MailboxRecipientMask popup is consumed after the native desk draw, without a // synthetic DeskRequest. The app polls the Session latch only at an idle desk. void show_notified_mailbox(MailboxState state); bool in_mailbox() const { return bool(mailbox_); } const MailboxActionRequest* pending_mailbox() const { return mailbox_ && mailbox_->pending() ? &*mailbox_->pending() : nullptr; } const MailboxCloseRequest* pending_mailbox_close() const { return pending_mailbox_close_ ? &*pending_mailbox_close_ : nullptr; } const BankRequest* pending_bank_action() const { return bank_ && bank_->pending() ? &*bank_->pending() : nullptr; } const TransferMarketRequest* pending_transfer_market() const { return transfer_market_ && transfer_market_->pending() ? &*transfer_market_->pending() : nullptr; } const OutgoingTransferRequest* pending_transfer_offer() const { return outgoing_transfer_ && outgoing_transfer_->pending() ? &*outgoing_transfer_->pending() : nullptr; } void show_transfer_offer(PreparationState, OutgoingTransferEditorState); void acknowledge_transfer_offer(PreparationState, OutgoingTransferEditorState); void reject_transfer_offer(std::string reason); void acknowledge_mailbox(MailboxState state, PreparationState preparation); void acknowledge_mailbox_close(const MailboxCloseRequest&, DeskState, PreparationState); void reject_mailbox_close(std::string reason); void reject_mailbox(std::string reason); const SettingsWriteRequest* pending_settings() const { return settings_ && settings_->pending() ? settings_->pending() : nullptr; } void acknowledge_settings(SettingsState state, DeskState desk, PreparationState preparation); void reject_settings(std::string reason); void acknowledge_settings_notice_release(); void acknowledge_settings_file(SettingsState state, DeskState desk, PreparationState preparation); void reject_settings_file(std::string reason); void cancel_settings_file(); void acknowledge_settings_closed(SettingsState, DeskState, PreparationState); void reject_settings_close(std::string reason); void show_settings(SettingsState state, uint64_t owner_sequence = 0, DeskRequest owner = {}); uint64_t settings_owner_sequence() const { return settings_owner_sequence_; } const DeskRequest& settings_desk_owner() const { return settings_desk_owner_; } uint64_t settings_owner_revision() const { return settings_ ? settings_->state().revision : settings_desk_owner_.revision; } void show_advertising(AdvertisingState state); const AdvertisingRequest* pending_advertising_action() const { return advertising_ && advertising_->pending() ? &*advertising_->pending() : nullptr; } void acknowledge_advertising(AdvertisingState, DeskState, PreparationState); void reject_advertising_action(std::string reason); void show_environment(EnvironmentView, const DeskRequest& owner); const EnvironmentScreen* environment() const { return environment_.get(); } const EnvironmentRequest* pending_environment() const { return environment_ && environment_->pending() ? &*environment_->pending() : nullptr; } void acknowledge_environment(EnvironmentView, std::optional preparation = {}); void reject_environment_action(std::string reason); bool in_environment() const { return bool(environment_); } void show_achievements(AchievementsState, const DeskRequest& owner); bool in_achievements() const { return bool(achievements_); } const AchievementsScreen* achievements() const { return achievements_.get(); } void show_strengths(StrengthsState, PreparationState, const DeskRequest& owner); void show_family_strengths(StrengthsState, PreparationState); void acknowledge_strengths(StrengthsState, PreparationState); void close_strengths(StrengthsState, PreparationState); void reject_strengths(std::string reason); bool in_strengths() const { return bool(strengths_); } const StrengthsScreen* strengths() const { return strengths_.get(); } const StrengthsRequest* pending_strengths() const { return strengths_&&strengths_->pending()?&*strengths_->pending():nullptr; } void show_top_scorers(TopScorersState, PreparationState, const DeskRequest& owner); void acknowledge_top_scorers(TopScorersState, PreparationState); void close_top_scorers(TopScorersState, PreparationState); void reject_top_scorers(std::string reason); bool in_top_scorers() const { return bool(top_scorers_); } const TopScorersScreen* top_scorers() const { return top_scorers_.get(); } const TopScorersRequest* pending_top_scorers() const { return top_scorers_ && top_scorers_->pending() ? &*top_scorers_->pending() : nullptr; } void show_desk_records(DeskRecordsState, const DeskRequest& owner); bool in_desk_records() const { return bool(desk_records_); } const DeskRecordsScreen* desk_records() const { return desk_records_.get(); } bool desk_records_points_active() const { return desk_records_&&desk_records_->points_active(); } bool advance_desk_records_point() { return desk_records_&&desk_records_->advance_point(); } bool finish_desk_records_points() { return desk_records_&&desk_records_->finish_points(); } void show_opportunities(OpportunitiesState, PreparationState, const DeskRequest& owner); void show_statistics_menu(const DeskRequest& owner, int transfer_history_count = 0); void show_alltime_table(AllTimeTableState); void show_world_cup_statistics(WorldCupStatisticsProjection); void show_finance_totals(FinanceTotals); void show_series_records(SeriesRecordsProjection); FlowResult finish_statistics_page_input(bool changed); const StatisticsPageAction* pending_statistics_page_action() const { return statistics_page_action_ ? &*statistics_page_action_ : nullptr; } void close_statistics_page(); bool in_statistics_page() const { return bool(alltime_table_||world_cup_statistics_||finance_totals_||series_records_); } void show_statistics_rankings(StatisticsRankingState state); void show_analytics(AnalyticsState state); void acknowledge_analytics(AnalyticsState state, PreparationState preparation); void close_analytics(); void reject_analytics(); bool in_analytics() const { return bool(analytics_); } const AnalyticsScreen* analytics() const { return analytics_.get(); } const AnalyticsRequest* pending_analytics() const { return analytics_ && analytics_->pending() ? &*analytics_->pending() : nullptr; } void show_minute_statistics(MinuteStatisticsProjection projection); void show_transfer_history(TransferHistoryProjection projection, const GameState& formatting_state, int source_origin_y); void acknowledge_statistics_rankings(StatisticsRankingState state); void close_statistics_rankings(); void reject_statistics_rankings(); bool in_statistics_rankings() const { return bool(statistics_rankings_); } bool in_minute_statistics() const { return bool(minute_statistics_); } bool in_transfer_history() const { return bool(transfer_history_); } const TransferHistoryScreen* transfer_history() const { return transfer_history_.get(); } const StatisticsRankingsScreen* statistics_rankings() const { return statistics_rankings_.get(); } const StatisticsRankingsRequest* pending_statistics_rankings() const { return statistics_rankings_ && statistics_rankings_->pending() ? &*statistics_rankings_->pending() : nullptr; } void close_statistics_menu(); void reject_statistics_menu(std::string reason); bool in_statistics_menu() const { return bool(statistics_menu_); } const StatisticsMenuScreen* statistics_menu() const { return statistics_menu_.get(); } const StatisticsMenuRequest* pending_statistics_menu() const { return statistics_menu_ && statistics_menu_->pending() ? &*statistics_menu_->pending() : nullptr; } void acknowledge_opportunities(OpportunitiesState, PreparationState); void close_opportunities(OpportunitiesState, PreparationState); void close_opportunities_for_statistics_parent(OpportunitiesState, PreparationState); void reject_opportunities(std::string reason); bool in_opportunities() const { return bool(opportunities_); } const OpportunitiesScreen* opportunities() const { return opportunities_.get(); } const OpportunitiesRequest* pending_opportunities() const { return opportunities_ && opportunities_->pending() ? &*opportunities_->pending() : nullptr; } void show_balance(BalanceState, const DeskRequest& owner); void acknowledge_balance(BalanceState); void close_balance(BalanceState, PreparationState); void reject_balance(std::string reason); bool in_balance() const { return bool(balance_); } const BalanceScreen* balance() const { return balance_.get(); } const BalanceRequest* pending_balance() const { return balance_&&balance_->pending()?&*balance_->pending():nullptr; } void show_other_games(OtherGamesState, PreparationState, const DeskRequest& owner); void acknowledge_other_games(OtherGamesState, PreparationState); void close_other_games(OtherGamesState, PreparationState); void reject_other_games(std::string reason); bool in_other_games() const { return bool(other_games_); } const OtherGamesScreen* other_games() const { return other_games_.get(); } const OtherGamesRequest* pending_other_games_action() const { return other_games_ && other_games_->pending() ? &*other_games_->pending() : nullptr; } FlowResult tick_balance_source_milliseconds(uint64_t now); void mark_balance_presented_source_milliseconds(uint64_t now); FlowResult tick_stadium_calculator_source_ticks(unsigned ticks); void mark_stadium_calculator_presented(); void show_calendar(CalendarState state, const DeskRequest& owner); const RescheduleAction* pending_reschedule_action() const { return calendar_ && calendar_->pending_reschedule() ? &*calendar_->pending_reschedule() : nullptr; } void acknowledge_reschedule(CalendarState state, DeskRequest owner, DeskState desktop, PreparationState preparation); void reject_reschedule(); bool source_mouse_wait_release_pending() const { return indoor_standings_release_barrier_ || reschedule_release_barrier_ || achievements_release_barrier_ || desk_records_release_barrier_; } const CalendarScreen* calendar() const { return calendar_.get(); } void show_indoor_standings(IndoorStandingsState state, const DeskRequest& owner); const IndoorStandingsScreen* indoor_standings() const { return indoor_standings_.get(); } bool in_indoor_standings() const { return bool(indoor_standings_); } bool in_reschedule_calendar() const { return calendar_ && calendar_->state().reschedule_manager >= 0; } void show_friendly_match(FriendlyMatchState state, int menu_kind = 6); const LeagueTableScreen* friendly_opponent_picker() const { return friendly_table_active_ ? league_table_.get() : friendly_match_ ? friendly_match_->opponent_table() : nullptr; } const FriendlyMatchScreen* friendly_question_screen() const { return friendly_match_ && friendly_match_->active_question() && !pending_friendly_action_ ? friendly_match_.get() : nullptr; } FlowResult expire_friendly_question(bool release_consumed = false); bool friendly_question_release_pending() const { return friendly_question_release_barrier_; } const FriendlyQuoteProjection* friendly_calendar_quote() const { return friendly_match_ && friendly_match_->stage() == FriendlyStage::calendar && friendly_match_->quote() ? &*friendly_match_->quote() : nullptr; } void show_national_friendly_picker(WorldCupStatisticsProjection, const DeskRequest& owner, int runtime_team); const NationalFriendlyUiOwner* national_friendly_owner() const { return national_friendly_picker_ ? &national_friendly_owner_ : nullptr; } const DeskRequest* national_friendly_desk_owner() const { return national_friendly_picker_ ? &national_friendly_desk_owner_ : nullptr; } bool national_friendly_family_active() const { return national_friendly_picker_; } void close_national_friendly_picker(); void show_national_friendly_calendar(FriendlyMatchState, FriendlyQuoteProjection, NationalFriendlyBookingRequest); const FriendlyMatchRequest* pending_friendly_action() const { return friendly_match_ && pending_friendly_action_ ? &*pending_friendly_action_ : nullptr; } bool acknowledge_friendly_quote(FriendlyQuoteProjection quote); bool acknowledge_friendly_booking(FriendlyBookingAck ack); bool acknowledge_friendly_booking(FriendlyBookingAck ack, DeskState desk, PreparationState preparation); void reject_friendly_action(std::string reason); void show_contracts(ContractsState state); const ContractRequest* pending_contract_action() const { return contracts_ ? contracts_->pending() : nullptr; } void acknowledge_contract_quote(ContractsState state, DeskState desk, PreparationState preparation); void acknowledge_contract_offer(ContractsState state, DeskState desk, PreparationState preparation); void acknowledge_contract_bonuses(ContractsState state, DeskState desk, PreparationState preparation); void acknowledge_contract_insurance(ContractsState state, DeskState desk, PreparationState preparation); void reject_contract_action(std::string reason); bool in_readonly_view() const { return bool(desk_records_ || achievements_ || indoor_standings_ || other_games_ || strengths_ || top_scorers_ || opportunities_ || statistics_menu_ || statistics_rankings_ || analytics_ || minute_statistics_ || transfer_history_ || league_pairings_ || calendar_ || league_table_ || mailbox_ || settings_ || advertising_ || alltime_table_ || world_cup_statistics_ || finance_totals_ || series_records_); } void acknowledge_preparation(PreparationState state, std::string transfer_notice = {}); void reject_preparation_action(std::string reason); void acknowledge_unchanged_transfer_market(); void acknowledge_transfer_market_preview(PreparationState, TransferMarketPreview); bool matches_pending_lineup(const LineupRequest&) const; bool matches_pending_pitch(const PitchRequest&) const; bool matches_pending_stadium(const StadiumRequest&) const; bool in_preparation_menu() const { return bool(other_games_ || balance_ || player_card_ || pitch_ || lineup_ || training_ || training_camp_ || bank_ || stadium_ || environment_ || toto_ || transfer_market_ || tactics_ || save_load_ || friendly_match_ || contracts_); } bool file_info_press(int x, int y) { return save_load_ && save_load_->info_press(x, y); } const DesktopScreen* desktop() const { return desktop_.get(); } std::string screen_name() const; std::string state_json() const; const SetupOptions& options() const { return setup_.options(); } const NewCareerRequest* pending_career() const { return pending_.get(); } const ManagerChoice* pending_manager() const { return awaiting_context_ ? &confirmed_.back() : nullptr; } private: FlowResult finish_statistics_rankings_input(bool changed); FlowResult finish_analytics_input(bool changed); bool joining_ = false, join_options_pending_ = false, join_choice_pending_ = false; DeskRequest join_origin_; std::unique_ptr join_setup_; std::vector join_choices_; uint64_t join_context_revision_ = 0; void acknowledge_contract_mutation(ContractsState, DeskState, PreparationState, ContractActionKind); std::filesystem::path data_; std::filesystem::path save_directory_; SetupScreen setup_; std::unique_ptr manager_; std::vector confirmed_; std::unique_ptr pending_; std::unique_ptr desktop_; std::unique_ptr matchday_results_; std::unique_ptr calendar_; std::unique_ptr indoor_standings_; bool indoor_standings_release_barrier_ = false; std::unique_ptr strengths_; std::unique_ptr top_scorers_; std::unique_ptr desk_records_; bool desk_records_release_barrier_ = false; std::unique_ptr opportunities_; std::unique_ptr statistics_menu_; std::unique_ptr statistics_rankings_; std::unique_ptr analytics_; std::unique_ptr minute_statistics_; std::unique_ptr transfer_history_; std::unique_ptr alltime_table_; std::unique_ptr world_cup_statistics_; bool national_friendly_picker_ = false; bool national_friendly_release_barrier_ = false; NationalFriendlyUiOwner national_friendly_owner_{}; DeskRequest national_friendly_desk_owner_{}; std::unique_ptr finance_totals_; std::unique_ptr series_records_; std::optional statistics_page_action_; int transfer_history_origin_y_ = 0; std::unique_ptr league_table_; std::unique_ptr family_table_range_dialog_; std::optional family_table_range_profile_; std::optional family_table_range_stage_; std::optional family_table_last_outcome_; std::optional family_table_dispatch_pending_; bool family_table_forecast_needs_present_ = false; bool family_table_source_clock_anchor_valid_ = false; bool family_table_reset_clock_after_present_ = false; uint64_t family_table_source_clock_anchor_ = 0; std::optional league_family_identity_; bool friendly_table_active_ = false; uint8_t league_family_child_ = 0; bool family_table_release_barrier_ = false; std::unique_ptr league_pairings_; std::unique_ptr balance_; std::unique_ptr other_games_; std::unique_ptr mailbox_; std::optional pending_mailbox_close_; std::unique_ptr settings_; std::unique_ptr settings_readme_; uint64_t settings_owner_sequence_ = 0; DeskRequest settings_desk_owner_{}; bool settings_release_barrier_ = false; bool settings_readme_release_barrier_ = false; std::unique_ptr advertising_; uint64_t advertising_generation_ = 1; std::unique_ptr friendly_match_; bool friendly_question_release_barrier_ = false; std::unique_ptr contracts_; std::unique_ptr environment_; std::unique_ptr achievements_; DeskRequest environment_owner_{}; uint64_t contracts_generation_ = 1; std::optional pending_friendly_action_; uint64_t next_friendly_request_id_ = 1; std::unique_ptr preparation_; std::unique_ptr lineup_; std::unique_ptr training_; std::unique_ptr training_camp_; std::unique_ptr bank_; std::unique_ptr stadium_; std::unique_ptr toto_; std::unique_ptr transfer_market_; std::unique_ptr outgoing_transfer_; std::unique_ptr save_load_; std::unique_ptr tactics_; std::unique_ptr pitch_; bool pitch_entry_pending_ = false; std::unique_ptr player_card_; FlowResult route_desk(DeskRequest); FlowResult finish_preparation_input(PreparationRequest, bool changed); FlowResult finish_file_input(bool changed); FlowResult finish_settings_input(bool changed); FlowResult finish_readonly_input(bool changed); FlowResult finish_league_pairings_input(bool changed); FlowResult finish_strengths_input(bool changed); FlowResult finish_top_scorers_input(bool changed); FlowResult finish_opportunities_input(bool changed); FlowResult finish_statistics_menu_input(bool changed); FlowResult finish_balance_input(bool changed); FlowResult finish_other_games_input(bool changed); bool engine_attached_ = false; bool balance_release_barrier_ = false; bool achievements_release_barrier_ = false; bool pitch_release_barrier_ = false; bool pitch_hold_release_barrier_ = false; bool reschedule_release_barrier_ = false; bool awaiting_context_ = false; std::vector confirmed_runtime_teams_; uint64_t roster_revision_ = 0; std::string roster_source_ = "master_database"; }; } // namespace bmh::ui