MainMenu.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "IScreen.hpp"
#include "app/AppContext.hpp"
#include "menus/main/ui/MainMenuUI.hpp"
#include "menus/pause/ConfirmModal.hpp"
#include "menus/settings/SystemMenuOverlay.hpp"
#include "network/DiscoveryClient.hpp"
#include "network/DiscoverySettings.hpp"
#include "network/MatchConfig.hpp"
#include "network/NetworkConfig.hpp"
#include "network/discovery/GlobalDiscoveryClient.hpp"
#include "renderer-new/NewRenderer.hpp"
 
#include <atomic>
#include <memory>
#include <mutex>
#include <optional>
#include <string>
#include <string_view>
#include <thread>
#include <vector>

struct JoinRequest
{
    std::string serverIp;        
    uint16_t serverPort;         
    uint32_t globalServerId = 0; 
    std::string serverName;      
};

class MainMenu : public IScreen
{
public:
    bool init(AppContext& ctx, ServerBrowserTab initialTab = ServerBrowserTab::LocalListing);
 
    SDL_AppResult event(SDL_Event* event) override;
    SDL_AppResult iterate() override;
    void quit() override;

    std::optional<JoinRequest> consumeJoinRequest();

    bool consumeHostRequest();

    bool consumeReturnToTitleScreenRequest();

    bool consumeExitRequest();

    void setJoinError(const std::string& error);

    void setLaunchError(const std::string& error);

    void setJoinInProgress(bool joining, const std::string& label = {});

    void setPopupMessage(const std::string& message);

    bool consumeLaunchRequest();

    bool consumeShutdownRequest();

    bool consumeGoToLobbyRequest();

    HostConfigState consumeDraftConfig() const;
 
private:
    enum class PendingConfirmAction
    {
        None,
        DiscardMatchChanges,
        ShutdownServer,
    };

    bool canManageCurrentServer() const;

    bool hasUnsavedServerChanges() const;

    HostConfigState draftConfig() const;

    bool updateServerSettings();

    void requestDiscardMatchChangesConfirm();

    void requestShutdownConfirm();
 
    NewRenderer* renderer = nullptr;                  
    SDL_Window* window = nullptr;                     
    Client* client = nullptr;                         
    HostedServer* hostedServer = nullptr;             
    HostConfigState* draft = nullptr;                 
    NetworkConfig* networkConfig = nullptr;           
    UserSettings* settings = nullptr;                 
    std::string_view settingsPath;                    
    SystemMenuOverlay systemMenu_;                    
    GlobalDiscoveryConfig discoveryConfig;
    JoinMenuState joinMenuState;                      
    std::string lastHostError;                        
    std::optional<MatchConfig> lastSyncedMatchConfig; 
    std::optional<DiscoverySettings> lastSyncedDiscoverySettings; 
    ConfirmModal confirm_;                                        
    PendingConfirmAction pendingConfirmAction = PendingConfirmAction::None; 
    std::optional<JoinRequest>
        pendingJoinRequest;          
    bool pendingHostRequest = false; 
    bool pendingLaunch = false;      
    bool pendingShutdown = false;    
    bool pendingGoToLobby = false;   
    bool pendingReturnToTitleScreenRequest =
        false;                       
    bool pendingExitRequest = false; 
    std::string joinError;           
    std::string popupMessage;        
    bool openPopupMessage = false;   
 
    std::unique_ptr<DiscoveryClient> localDiscoveryClient = std::make_unique<DiscoveryClient>();

    void startGlobalRefresh(bool force = false);

    void joinRefreshThreadIfFinished();
 
    std::vector<net::discovery::ServerInfo> globalServers;       
    std::vector<DiscoveryClient::DiscoveredServer> localServers; 
    std::string browserError;                                    
    std::mutex browserMutex;                                     
    std::thread browserThread;                                   
    std::atomic<bool> browserRefreshing{false};                  
    uint64_t lastBrowserRefreshMs = 0;                           
};