waitingForHostState.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
******************************************************************************/
 
//! \file waitingForHostState.h
//! \brief Defines a player station state for waiting to join a hosted session
//!
//! The DtWaitingForHostState class implements a state that displays a waiting screen
//! while monitoring for an available hosted session to join. It handles session status
//! updates, can start an ownship simulation if configured, and transitions to the
//! joined session state when a host becomes available.
 
#pragma once
 
#include "vrePlayerStation/export.h"
 
#include "vrePlayerStation/playerStationState.h"
 
#include "vreMessageManager/vreMessage.h"
 
#include "vreMessages/vrfSessionStatus.h"
 
namespace makVre
{
//! Forward declaration of the waiting page UI class
class DtVreWaitingPage;
 
//! \brief A state that displays a waiting screen while monitoring for a hosted session to join
//!
//! This state is activated when the user chooses to join a session. It displays
//! a waiting page and monitors for session status updates. When a hosted session
//! with a terrain becomes available, it transitions to the joined session state.
//! If configured, it can also start an ownship simulation.
class PLAYERSTATION_DLL DtWaitingForHostState : virtual public DtPlayerStationState
{
public:
   //! \brief Constructor for the waiting for host state
   //! \param app Reference to the player station application
   //!
   //! Initializes the state with a reference to the application and sets default values.
   DtWaitingForHostState(DtPlayerStationApp& app);
 
   //! \brief Virtual destructor
   virtual ~DtWaitingForHostState() override;
 
   //! \brief Called when entering this state
   //! \param args Pointer to arguments containing a VrfSessionStatusMessage
   //!
   //! Sets up the waiting page UI, registers message handlers, and checks the
   //! startup configuration. If configured, it may start an ownship simulation.
   //! It also determines if the application is in join-only mode based on the
   //! application mode or startup configuration.
   virtual void onEnter(const DtPlayerStationStateArgs* args) override;
 
   //! \brief Called when exiting this state
   //!
   //! Removes message handlers and closes the waiting page UI.
   virtual void onExit() override;
 
   //! \brief Called every frame to update the state
   //! \param dt Time elapsed since the last frame in seconds
   //!
   //! Performs periodic updates for this state, currently minimal implementation.
   virtual void tick(double dt) override;
 
protected:
   //! \brief Handles session status messages
   //! \param msg The session status message
   //! \return Message handling result (HANDLED or IGNORED)
   //!
   //! Processes session status updates. If a terrain is available, creates a
   //! SessionLoadDataMessage and transitions to the JOINED_SESSION_STATE. If no
   //! terrain is available and not in join-only mode, transitions back to the
   //! SESSION_MENU_STATE and stops the ownship simulation if it was started.
   virtual DtVreMessageResult handleVrfSessionStatus(DtVreMessage* msg);
 
   //! \brief Starts the ownship simulation backend
   //! \return True if the ownship simulation was started, false if it was already running
   //!
   //! This method initiates the ownship simulation backend by creating and queuing a
   //! StartBackendMessage. It checks whether the simulation has already been started
   //! by examining the "ownshipSimStarted" attribute in the application attribute store.
   //! If the simulation is not running, it:
   //! - Creates a StartBackendMessage with appropriate host/ownship settings
   //! - Displays a notification with the simulation address
   //! - Sets the "ownshipSimStarted" attribute to true
   //!
   //! \note This method will not start the simulation if it has already been started
   //! \note The ownship mode is determined by checking if a VRF host exists
   virtual bool startOwnship();
 
   //! \brief Reference to the waiting page UI component
   std::shared_ptr<DtVreWaitingPage> myWaitingPage;
 
   //! \brief Flag indicating if the application is in join-only mode
   //!
   //! When true, the application will only attempt to join sessions and will not
   //! return to the session menu if no host is available.
   bool myJoinOnlyMode;
 
   //! \brief Cached copy of the session status message
   //!
   //! Contains information about the current session status, including whether
   //! the session is hosted and what terrain is being used.
   std::shared_ptr<VrfSessionStatusMessage> mySessionData;
};
 
} // namespace makVre