vrfRemoteControlConnector.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
******************************************************************************/
 
//! \file vrfRemoteControlConnector.h
//! \brief Defines the DtVrfRemoteControlConnector class for communication with VR-Forces backend
//!
//! This connector provides functionality to remotely control a VR-Forces backend,
//! including session management, entity control, and real-time data exchange.
 
#pragma once
 
#include "vrePlayerStationConnector/export.h"
#include "vrePlayerStationConnector/simEventConnector.h"
 
#include "vreMessages/loadBackend.h"
#include "vreMessages/createNewOwnship.h"
#include "vreMessages/backendStatus.h"
#include "vreMessages/vrfSessionStatus.h"
 
#include <vrfutil/rwUUID.h>
 
#include <vlpi/simulationAddress.h>
 
#include <vector>
#include <utility>
 
//! \brief Forward declaration of the exercise connection class
class DtExerciseConn;
 
//! \brief Forward declaration of the VRF object message class
class DtVrfObjectMessage;
 
//! \brief Forward declaration of the VRF message interface class
class DtVrfMessageInterface;
 
//! \brief Forward declaration of the reflected entity list class
class DtReflectedEntityList;
 
//! \brief Forward declaration of the entity identifier class
class DtEntityIdentifier;
 
//! \brief Forward declaration of the reflected entity class
class DtReflectedEntity;
 
//! \brief Forward declaration of the backend map class
class DtBackendMap;
 
//! \brief Forward declaration of the reflected extended entity list class
class DtReflectedExtEntityList;
 
//! \brief Forward declaration of the reflected extended entity class
class DtReflectedExtEntity;
 
//! \brief Forward declaration of the reflected control object list class
class DtReflectedControlObjectList;
 
//! \brief Forward declaration of the resource monitor response interface class
class DtIfResourceMonitorResponse;
 
//! \brief Forward declaration of the sensor data interface class
class DtIfSensorData;
 
//! \brief Forward declaration of the simulation message class
class DtSimMessage;
 
//! \brief Forward declaration of the simulation interface content class
class DtSimInterfaceContent;
 
//! \brief Forward declaration of the reflected control object class
class DtReflectedControlObject;
 
//! \brief Forward declaration of the reflected environment process class
class DtReflectedEnvironmentProcess;
 
//! \brief Forward declaration of the communication manager class
class DtCommunicationManager;
 
namespace makVrf
{
//! \brief Forward declaration of the VR-Link VRF remote controller class
class DtVrlinkVrfRemoteController;
} // namespace makVrf
 
namespace makVrfEvents
{
//! \brief Forward declaration of the VRF event class
class DtEvent;
} // namespace makVrfEvents
 
namespace makVre
{
//! \brief Structure containing information about a reflected extended entity
//!
//! Stores essential identification and type information about an entity in the
//! simulation, allowing for efficient lookups and entity management
struct DtReflectedExtEntityInfo
{
   //! \brief Entity identifier
   DtEntityIdentifier myEntityId;
 
   //! \brief Entity type information
   DtEntityType myEntityType;
 
   //! \brief Universally unique identifier for the entity
   DtUUID myUUID;
 
   //! \brief Marking text (name/label) for the entity
   DtString myMarkingText;
};
 
//! \brief Structure containing entity control capabilities
//!
//! Manages the relationship between an entity and its associated roles and
//! function groups, defining what capabilities are available for controlling the entity
struct VRL_DLL ControlSet
{
   //! \brief Default constructor
   //!
   //! Initializes the entity ID to a null identifier
   ControlSet() { entityId = DtEntityIdentifier::nullId(); }
 
   //! \brief Checks if the control set is valid
   //! \return True if the entity ID is not null, false otherwise
   bool valid() { return entityId != DtEntityIdentifier::nullId(); }
 
   //! \brief Entity identifier
   DtEntityIdentifier entityId;
 
   //! \brief Set of function groups available for this entity
   std::set<DtString> functionGroups;
 
   //! \brief Vector of roles available for this entity
   std::vector<std::string> roles;
};
 
//! \brief Connector for remote communication with VR-Forces backends
//!
//! DtVrfRemoteControlConnector provides a comprehensive interface for controlling
//! and communicating with a VR-Forces backend. It handles session management,
//! entity creation/removal, simulation control (run/pause/rewind), and processes
//! various data types sent from the backend, including radar data, entity updates,
//! and sensor information.
class VRL_DLL DtVrfRemoteControlConnector : public DT_PROTOCOL_NAMESPACE::DtSimEventConnector
{
public:
   //! \brief Default constructor
   DtVrfRemoteControlConnector();
 
   //! \brief Virtual destructor
   virtual ~DtVrfRemoteControlConnector() override;
 
   //! \brief Installs the VRF remote control connector with the application and connection
   //! \param app Pointer to the player station application
   //! \param communicationManager Pointer to the communication manager
   //! \param connection Pointer to the protocol-specific VR-Link connection
   //! \param vrfSessionId Session ID for the VRF backend
   //!
   //! Initializes the connector with the provided application, communication manager, and connection,
   //! registers message handlers for various message types, and sets up the VRF remote controller
   virtual void install(DtPlayerStationApp* app, DtCommunicationManager* communicationManager,
      makVrv::DT_PROTOCOL_NAMESPACE::DtVrlinkConnection* connection, int vrfSessionId);
 
   //! \brief Performs periodic processing of backend and session status
   //!
   //! Updates backend and session status information, and processes any pending
   //! entity creations or deletions
   virtual void tick() override;
 
   //! \brief Shuts down the VRF remote control connector
   //!
   //! Removes message handlers and cleans up resources
   virtual void shutdown() override;
 
   //! \brief Gets the VRF remote controller
   //! \return Pointer to the VRF remote controller
   virtual makVrf::DtVrlinkVrfRemoteController* vrfRemoteController();
 
   //! \brief Gets the reflected entity list
   //! \return Pointer to the reflected entity list
   virtual DtReflectedEntityList* reflectedEntityList();
 
   //! \brief Handles the creation of a local entity
   //! \param name The name of the created entity
   //! \param id The entity identifier of the created entity
   //! \param uuid The universally unique identifier of the created entity
   //!
   //! Called when a new local entity is created in the simulation. Updates
   //! internal entity tracking information and notifies listeners.
   virtual void handleLocalEntityCreated(const DtString& name, const DtEntityIdentifier& id, const DtUUID& uuid);
 
   //! \brief Processes a resource response event
   //! \param evt The event containing resource response data
   //!
   //! Handles resource response events from the VR-Forces backend, which
   //! typically include information about available resources like weapons,
   //! sensors, or other entity equipment.
   virtual void processResourceResponse(const makVrfEvents::DtEvent& evt);
 
   //! \brief Handles sensor update data
   //! \param sensorData Pointer to the sensor data interface
   //!
   //! Processes updates from entity sensors, including detection information
   //! about other entities. Updates the local representation of sensor information
   //! and forwards relevant data to subscribed components.
   virtual void handleSensorUpdate(DtIfSensorData* sensorData);
 
   //       virtual void handleWeatherObjectDiscovered(DtReflectedControlObject* obj);
   //      virtual void handleWeatherObjectRemoved(DtReflectedControlObject* obj);
 
   //! \brief Handles discovery of an action menu control object
   //! \param obj Pointer to the discovered control object
   //!
   //! Called when an action menu control object is discovered in the simulation.
   //! These objects define available actions that can be performed by entities
   //! and are used to populate action menus in the user interface.
   virtual void handleActionMenuControlObjectDiscovered(DtReflectedControlObject* obj);
 
   //! \brief Handles removal of an action menu control object
   //! \param obj Pointer to the removed control object
   //!
   //! Called when an action menu control object is removed from the simulation.
   //! Updates the UI to remove any corresponding action menu entries.
   virtual void handleActionMenuControlObjectRemoved(DtReflectedControlObject* obj);
 
   //! \brief Handles removal of an entity from the simulation
   //! \param entity Pointer to the removed entity
   //!
   //! Called when an entity is removed from the simulation. Updates internal
   //! entity tracking information and notifies listeners of the removal.
   virtual void handleEntityRemoved(const DtReflectedExtEntity* entity);
   //! \brief Handles addition of an entity to the simulation
   //! \param entity Pointer to the added entity
   //!
   //! Called when a new entity is added to the simulation. Updates internal
   //! entity tracking information and notifies listeners of the addition.
   virtual void handleEntityAdded(const DtReflectedExtEntity* entity);
 
   //! \brief Chat message handling methods
   //! @{
 
   //! \brief Processes a chat event from VR-Forces
   //! \param evt The event containing the chat message data
   //!
   //! Processes chat events from the VR-Forces backend and forwards
   //! them to the appropriate chat interface components.
   virtual void processChatEvent(const makVrfEvents::DtEvent& evt);
 
   //! \brief Handles a chat message from VR-Engage
   //! \param message The chat message to process
   //! \return Message result indicating how the message was handled
   //!
   //! Processes chat messages from VR-Engage components and forwards
   //! them to the VR-Forces backend for distribution.
   virtual DtVreMessageResult handleChatEvent(DtVreMessage* message);
   //! @}
 
   //! \brief Session status and configuration message handlers
   //! @{
 
   //! \brief Handles a request for VRF session status
   //! \param message The session status request message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes requests for the current session status and sends a response
   //! containing the session status information.
   virtual DtVreMessageResult handleVrfSessionStatusRequest(DtVreMessage* message);
 
   //! \brief Handles a request for the session simulation model set list
   //! \param message The SMS list request message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes requests for the list of simulation model sets (SMS) in the
   //! current session and sends a response with the SMS list.
   virtual DtVreMessageResult handleSessionSmsListRequest(DtVreMessage* message);
 
   //! \brief Handles a request for the session play state
   //! \param message The play state request message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes requests for the current play state (running, paused, etc.)
   //! of the session and sends a response with the play state information.
   virtual DtVreMessageResult handleSessionPlayStateRequest(DtVreMessage* message);
 
   //! \brief Handles a request to set the default SMS list
   //! \param message The set default SMS list message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes requests to set the default list of simulation model sets (SMS)
   //! for the current session or for new sessions.
   virtual DtVreMessageResult handleSetDefaultSmsList(DtVreMessage* message);
   //! @}
 
   //! \brief Backend management message handlers
   //! @{
 
   //! \brief Handles a request to set backend configuration
   //! \param message The set backend configuration message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes requests to configure the VR-Forces backend, including
   //! settings for network communication, simulation parameters, and
   //! other backend-specific options.
   virtual DtVreMessageResult handleSetBackendConfig(DtVreMessage* message);
 
   //! \brief Handles a request to start the backend
   //! \param message The start backend message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes requests to start the VR-Forces backend process.
   //! This typically launches the backend executable and establishes
   //! a connection to it.
   virtual DtVreMessageResult handleStartBackend(DtVreMessage* message);
 
   //! \brief Handles a request to stop the backend
   //! \param message The stop backend message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes requests to stop the VR-Forces backend process.
   //! This typically terminates the backend executable and releases
   //! any associated resources.
   virtual DtVreMessageResult handleStopBackend(DtVreMessage* message);
 
   //! \brief Handles a request for backend status
   //! \param message The backend status request message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes requests for the current status of the VR-Forces backend
   //! and sends a response with the status information.
   virtual DtVreMessageResult handleRequestBackendStatus(DtVreMessage* message);
 
   //! \brief Handles a request to load a scenario into the backend
   //! \param message The load backend message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes requests to load a specific scenario file into the
   //! VR-Forces backend, which initializes the simulation environment
   //! with predefined entities, settings, and initial conditions.
   virtual DtVreMessageResult handleLoadBackend(DtVreMessage* message);
   //! @}
 
   //! \brief Simulation control message handlers
   //! @{
 
   //! \brief Handles a request to run the simulation
   //! \param message The run simulation message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes requests to start or resume the simulation, which begins
   //! or continues the advancement of simulation time and entity dynamics.
   virtual DtVreMessageResult handleVrfRun(DtVreMessage* message);
 
   //! \brief Handles a request to pause the simulation
   //! \param message The pause simulation message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes requests to pause the simulation, which freezes the advancement
   //! of simulation time and entity dynamics while maintaining the current state.
   virtual DtVreMessageResult handleVrfPause(DtVreMessage* message);
 
   //! \brief Handles a request to rewind the simulation
   //! \param message The rewind simulation message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes requests to rewind the simulation to its initial state,
   //! resetting all entities and simulation time to their starting conditions.
   virtual DtVreMessageResult handleVrfRewind(DtVreMessage* message);
   //! @}
 
   //! \brief Entity control message handlers
   //! @{
 
   //! \brief Handles a request to create a new ownship entity
   //! \param message The create new ownship message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes requests to create a new entity in the simulation that will be
   //! directly controlled by the user. This typically creates the entity with
   //! specific attributes and assigns control of it to the requesting player station.
   virtual DtVreMessageResult handleCreateNewOwnship(DtVreMessage* message);
 
   //! \brief Handles a request to destroy an ownship entity
   //! \param message The destroy ownship message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes requests to remove a user-controlled entity from the simulation.
   //! This releases control of the entity and removes it from the simulation.
   virtual DtVreMessageResult handleDestroyNewOwnship(DtVreMessage* message);
 
   //! \brief Handles a request to take control of an existing entity
   //! \param message The take control message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes requests to take control of an existing entity in the simulation.
   //! This assigns control of the specified entity to the requesting player station.
   virtual DtVreMessageResult handleVrfTakeControlOf(DtVreMessage* message);
 
   //! \brief Handles a request to release control of an entity
   //! \param message The release control message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes requests to release control of an entity. This removes the player
   //! station's control over the entity but leaves the entity in the simulation.
   virtual DtVreMessageResult handleVrfReleaseControlOf(DtVreMessage* message);
   //! @}
 
   //! \brief Entity manipulation message handlers
   //! @{
 
   //! \brief Handles joystick input for entity control
   //! \param msg The joystick input message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes joystick input messages and applies the corresponding
   //! movement and control commands to the controlled entity.
   virtual DtVreMessageResult handleJoystick(DtVreMessage* msg);
 
   //! \brief Handles a request to reset a player entity
   //! \param msg The reset player message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes requests to reset a player entity to its initial state,
   //! typically restoring its position, orientation, and other attributes.
   virtual DtVreMessageResult handleResetPlayer(DtVreMessage* msg);
 
   //! \brief Handles a request to set an entity's location
   //! \param msg The set location message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes requests to set the position of an entity in the simulation.
   virtual DtVreMessageResult handleSetLocation(DtVreMessage* msg);
 
   //! \brief Handles a request to set an entity's heading
   //! \param msg The set heading message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes requests to set the heading (yaw) of an entity in the simulation.
   virtual DtVreMessageResult handleSetHeading(DtVreMessage* msg);
 
   //! \brief Handles a request to set an entity's pitch
   //! \param msg The set pitch message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes requests to set the pitch of an entity in the simulation.
   virtual DtVreMessageResult handleSetPitch(DtVreMessage* msg);
 
   //! \brief Handles a request to set an entity's roll
   //! \param msg The set roll message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes requests to set the roll of an entity in the simulation.
   virtual DtVreMessageResult handleSetRoll(DtVreMessage* msg);
 
   //! \brief Handles a request to set an entity's altitude
   //! \param msg The set altitude message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes requests to set the altitude of an entity in the simulation.
   virtual DtVreMessageResult handleSetAltitude(DtVreMessage* msg);
 
   //! \brief Handles an embark/disembark message
   //! \param msg The embark message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes requests for an entity to embark into or disembark from another entity.
   //! This typically involves human entities entering or exiting vehicles.
   virtual DtVreMessageResult handleEmbarkMessage(DtVreMessage* msg);
 
   //! \brief Handles a request to set an entity's appearance
   //! \param msg The set appearance message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes requests to change the visual appearance of an entity,
   //! such as its model, markings, or other visual attributes.
   virtual DtVreMessageResult handleSetAppearanceMessage(DtVreMessage* msg);
 
   //! \brief Handles a request to rename an entity
   //! \param msg The rename message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes requests to change the name or marking text of an entity in the simulation.
   virtual DtVreMessageResult handleRenameMessage(DtVreMessage* msg);
   //! @}
   //! \brief Simulation state and task message handlers
   //! @{
 
   //! \brief Handles requests for simulation state information
   //! \param msg The request simulation state message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes requests for the current state of the simulation and sends
   //! a response with comprehensive simulation state information.
   virtual DtVreMessageResult handleRequestSimulationStateMessage(DtVreMessage* msg);
 
   //! \brief Handles task-related messages
   //! \param msg The VRF task message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes messages related to entity tasks, including task assignment,
   //! modification, and cancellation. These tasks define the behaviors and
   //! objectives for entities in the simulation.
   virtual DtVreMessageResult handleVrfTaskMessages(DtVreMessage* msg);
 
   //! \brief Handles data request messages
   //! \param msg The set data requests message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes messages that configure what data should be regularly sent from
   //! the VR-Forces backend to the VR-Engage client, such as entity updates,
   //! sensor data, or other simulation information.
   virtual DtVreMessageResult handleVrfSetDataRequests(DtVreMessage* msg);
 
   //! \brief Handles sensor-related messages
   //! \param msg The VRF sensor message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes messages related to entity sensors, including sensor activation,
   //! configuration, and mode changes. These control how entities detect and
   //! track other entities in the simulation.
   virtual DtVreMessageResult handleVrfSensorMessages(DtVreMessage* msg);
 
   //! \brief Handles requests to set a laser code
   //! \param msg The set laser code message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes messages to set a laser designation code for a weapon system,
   //! which is used to guide laser-guided munitions to their targets.
   virtual DtVreMessageResult handleSetLaserCode(DtVreMessage* msg);
 
   //! \brief Handles scripted set messages
   //! \param msg The scripted set message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes messages that contain sets of scripted commands or parameters
   //! to be applied to entities or the simulation environment.
   virtual DtVreMessageResult handleScriptedSet(DtVreMessage* msg);
   //! @}
 
   //! \brief Entity action and equipment message handlers
   //! @{
 
   // These methods are commented out but kept for reference in future implementations
   // virtual DtVreMessageResult handleCreateWaypoint(DtVreMessage* msg);
   // virtual DtVreMessageResult handleCreateRoute(DtVreMessage* msg);
 
   //! \brief Handles requests to set rules of engagement
   //! \param msg The set rules of engagement message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes messages to configure an entity's rules of engagement, which
   //! define when and how it can engage targets or respond to threats.
   virtual DtVreMessageResult handleSetRulesOfEngagement(DtVreMessage* msg);
 
   //! \brief Handles requests to trigger a simulation event
   //! \param msg The trigger event message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes messages to trigger specific events in the simulation,
   //! such as scripted actions, effects, or environmental changes.
   virtual DtVreMessageResult handleTriggerEvent(DtVreMessage* msg);
 
   //! \brief Handles requests to set an entity's light state
   //! \param msg The set light state message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes messages to control an entity's lights, such as headlights,
   //! running lights, or interior lighting.
   virtual DtVreMessageResult handleSetLightState(DtVreMessage* msg);
 
   //! \brief Handles requests to set a human entity's hand item
   //! \param msg The set hand item message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes messages to change what item a human entity is holding,
   //! such as a weapon, tool, or other equipment.
   virtual DtVreMessageResult handleSetHandItem(DtVreMessage* msg);
 
   //! \brief Handles requests to track a specific laser code
   //! \param msg The track laser code message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes messages to configure a weapon system to track a specific
   //! laser designation code, typically used for guiding laser-guided munitions.
   virtual DtVreMessageResult handleTrackLaserCode(DtVreMessage* msg);
   //! @}
 
   //! \brief Subscription management message handlers
   //! @{
 
   //! \brief Handles requests to subscribe to radar warning receiver data
   //! \param msg The RWR subscription message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes requests to subscribe to radar warning receiver (RWR) data,
   //! which provides information about radar emissions detected by an entity.
   virtual DtVreMessageResult handleRwrSubscription(DtVreMessage* msg);
 
   //! \brief Handles requests to unsubscribe from radar warning receiver data
   //! \param msg The RWR unsubscription message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes requests to stop receiving radar warning receiver (RWR) data.
   virtual DtVreMessageResult handleRwrUnsubscription(DtVreMessage* msg);
 
   //! \brief Handles requests to subscribe to sensor data
   //! \param msg The sensor subscription message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes requests to subscribe to entity sensor data, which includes
   //! information about detections and tracks from the entity's sensors.
   virtual DtVreMessageResult handleSensorSubscription(DtVreMessage* msg);
 
   //! \brief Handles requests to unsubscribe from sensor data
   //! \param msg The sensor unsubscription message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes requests to stop receiving entity sensor data.
   virtual DtVreMessageResult handleSensorUnsubscription(DtVreMessage* msg);
 
   //! \brief Handles requests to subscribe to radar state data
   //! \param msg The radar state subscription message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes requests to subscribe to radar state data, which includes
   //! information about the operating parameters and mode of an entity's radar.
   virtual DtVreMessageResult handleRadarStateSubscription(DtVreMessage* msg);
 
   //! \brief Handles requests to unsubscribe from radar state data
   //! \param msg The radar state unsubscription message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes requests to stop receiving radar state data.
   virtual DtVreMessageResult handleRadarStateUnsubscription(DtVreMessage* msg);
   //! @}
 
   //! \brief Targeting and weapon system message handlers
   //! @{
 
   //! \brief Handles updates to designated targets
   //! \param msg The designated targets update message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes messages that update the list of designated targets for
   //! an entity's weapon systems or sensors.
   virtual DtVreMessageResult handleDesignatedTargetsUpdate(DtVreMessage* msg);
 
   //! \brief Handles requests to set an entity's mode and submode
   //! \param msg The set mode and submode message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes messages to change an entity's operating mode and submode,
   //! which affect its behavior, capabilities, and available actions.
   virtual DtVreMessageResult handleSetModeAndSubmode(DtVreMessage* msg);
   //! @}
 
   //! \brief Gimbal and sensor control message handlers
   //! @{
 
   //! \brief Handles requests to track a location with a gimbal system
   //! \param msg The set gimbal track location message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes messages to direct a gimbal-mounted sensor or weapon to
   //! track a specific geographic location.
   virtual DtVreMessageResult handleSetGimbalTrackLocation(DtVreMessage* msg);
 
   //! \brief Handles requests to track an object with a gimbal system
   //! \param msg The set gimbal track object message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes messages to direct a gimbal-mounted sensor or weapon to
   //! track a specific entity or object in the simulation.
   virtual DtVreMessageResult handleSetGimbalTrackObject(DtVreMessage* msg);
 
   //! \brief Handles requests to set the tracking mode of a gimbal system
   //! \param msg The set gimbal track mode message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes messages to change the tracking mode of a gimbal-mounted
   //! sensor or weapon, such as manual, auto-track, or scan modes.
   virtual DtVreMessageResult handleSetGimbalTrackMode(DtVreMessage* msg);
 
   //! \brief Handles requests to set the sweep pattern of an antenna
   //! \param msg The set antenna sweep message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes messages to configure the sweep pattern of a radar or
   //! other scanning antenna, including parameters like azimuth, elevation,
   //! and scan rate.
   virtual DtVreMessageResult handleSetAntennaSweep(DtVreMessage* msg);
   //! @}
 
   //! \brief Environmental request handlers
   //! @{
 
   //! \brief Handles requests for wind information
   //! \param msg The wind request message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes requests for current wind speed and direction information
   //! from the simulation environment.
   virtual DtVreMessageResult handleWindRequest(DtVreMessage* msg);
 
   virtual DtVreMessageResult handleSetStateProperties(DtVreMessage* msg);
 
   //! \brief Processes environment process discovery criteria
   //! \param envProcess Pointer to the environment process to evaluate
   //! \return True if the process meets the discovery criteria, false otherwise
   //!
   //! Evaluates whether an environment process (such as weather effects)
   //! should be discovered and made available to the client. This allows
   //! filtering of environment processes based on application-specific criteria.
   virtual bool processEnvProcessDiscoveryCriteria(DtReflectedEnvironmentProcess* envProcess);
   //! @}
 
   //! \brief Status and query message handlers
   //! @{
 
   //! \brief Handles VR-Engage status messages
   //! \param message The VRE status message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes status messages from VR-Engage clients, which typically
   //! include information about the client's state, active entities, and
   //! other operational parameters.
   virtual DtVreMessageResult handleVreStatus(DtVreMessage* message);
 
   //! \brief Handles requests for entities by type
   //! \param msg The request entities by type message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes requests to retrieve a list of entities of a specific type
   //! from the simulation. Returns information about matching entities to
   //! the requesting client.
   virtual DtVreMessageResult handleRequestEntitiesByType(DtVreMessage* msg);
   //! @}
 
   //! \brief Message callback methods
   //! @{
 
   //! \brief Static callback for radar warning receiver data messages
   //! \param msg Pointer to the simulation message containing RWR data
   //! \param usr Pointer to user data (typically the connector instance)
   //!
   //! Static callback function registered with the messaging system to receive
   //! radar warning receiver data messages. Forwards the message to the
   //! appropriate instance method for processing.
   static void rwrDataMessageCallback(DtSimMessage* msg, void* usr);
 
   //! \brief Processes radar warning receiver data messages
   //! \param msg Pointer to the simulation message containing RWR data
   //!
   //! Processes radar warning receiver data messages from the VR-Forces backend
   //! and forwards the information to subscribed clients.
   virtual void processRwrDataMessage(DtSimMessage* msg);
 
   //! \brief Commented-out sensor data callback methods
   //!
   //! These methods are commented out but kept for reference in future implementations
   //! for handling VR-Forces sensor contact messages.
   //      static void sensorDataMessageCallback(DtSimMessage* msg, void* usr);
   //      virtual void processSensorDataMessage(DtSimMessage* msg);
 
   //! \brief Static callback for radar data messages
   //! \param msg Pointer to the simulation message containing radar data
   //! \param usr Pointer to user data (typically the connector instance)
   //!
   //! Static callback function registered with the messaging system to receive
   //! extended Player Station radar contact messages. Forwards the message to the
   //! appropriate instance method for processing.
   static void radarDataMessageCallback(DtSimMessage* msg, void* usr);
 
   //! \brief Processes radar data messages
   //! \param msg Pointer to the simulation message containing radar data
   //!
   //! Processes radar data messages from the VR-Forces backend, which include
   //! information about radar contacts, and forwards the information to subscribed clients.
   virtual void processRadarDataMessage(DtSimMessage* msg);
 
   //! \brief Static callback for radar state data messages
   //! \param msg Pointer to the simulation message containing radar state data
   //! \param usr Pointer to user data (typically the connector instance)
   //!
   //! Static callback function registered with the messaging system to receive
   //! radar state messages. Forwards the message to the appropriate instance method
   //! for processing.
   static void radarStateDataMessageCallback(DtSimMessage* msg, void* usr);
 
   //! \brief Processes radar state data messages
   //! \param msg Pointer to the simulation message containing radar state data
   //!
   //! Processes radar state messages from the VR-Forces backend, which include
   //! information about radar operating parameters and modes, and forwards the
   //! information to subscribed clients.
   virtual void processRadarStateDataMessage(DtSimMessage* msg);
 
   //! \brief Static callback for assign role player messages
   //! \param msg Pointer to the simulation message containing role assignment data
   //! \param usr Pointer to user data (typically the connector instance)
   //!
   //! Static callback function registered with the messaging system to receive
   //! role player assignment messages. Forwards the message to the appropriate
   //! instance method for processing.
   static void assignRolePlayerMessageCallback(DtSimMessage* msg, void* usr);
 
   //! \brief Processes assign role player messages
   //! \param msg Pointer to the simulation message containing role assignment data
   //!
   //! Processes messages that assign a role to a player in the simulation,
   //! which typically grants control of an entity to a specific player station.
   virtual void processAssignRolePlayerMessage(DtSimMessage* msg);
 
   //! \brief Static callback for unassign role player messages
   //! \param msg Pointer to the simulation message containing role unassignment data
   //! \param usr Pointer to user data (typically the connector instance)
   //!
   //! Static callback function registered with the messaging system to receive
   //! role player unassignment messages. Forwards the message to the appropriate
   //! instance method for processing.
   static void unassignRolePlayerMessageCallback(DtSimMessage* msg, void* usr);
 
   //! \brief Processes unassign role player messages
   //! \param msg Pointer to the simulation message containing role unassignment data
   //!
   //! Processes messages that remove a role assignment from a player in the simulation,
   //! which typically revokes control of an entity from a specific player station.
   virtual void processUnassignRolePlayerMessage(DtSimMessage* msg);
   //! @}
 
   //! \brief Static callback for VRE status messages
   //! \param msg Pointer to the simulation message containing VRE status data
   //! \param usr Pointer to user data (typically the connector instance)
   //!
   //! Static callback function registered with the messaging system to receive
   //! VR-Engage status messages. Forwards the message to the appropriate
   //! instance method for processing.
   static void vreStatusMessageCallback(DtSimMessage* msg, void* usr);
 
   //! \brief Processes VRE status messages
   //! \param msg Pointer to the simulation message containing VRE status data
   //!
   //! Processes VR-Engage status messages, which include information about
   //! the state of VR-Engage clients and their controlled entities.
   virtual void processVreStatusMessage(DtSimMessage* msg);
 
   //! \brief Static callback for text report messages
   //! \param msg Pointer to the VRF object message containing text report data
   //! \param usr Pointer to user data (typically the connector instance)
   //!
   //! Static callback function registered with the messaging system to receive
   //! text report messages. Forwards the message to the appropriate instance
   //! method for processing.
   static void textReportCallback(const DtVrfObjectMessage* msg, void* usr);
 
   //! \brief Processes text report messages
   //! \param msg Pointer to the VRF object message containing text report data
   //!
   //! Processes text report messages from the VR-Forces backend, which typically
   //! contain status reports or notifications about simulation events.
   virtual void processTextReport(const DtVrfObjectMessage* msg);
 
   //! \brief Static callback for tactical data link track list messages
   //! \param msg Pointer to the simulation message containing TDL track list data
   //! \param usr Pointer to user data (typically the connector instance)
   //!
   //! Static callback function registered with the messaging system to receive
   //! tactical data link track list messages. Forwards the message to the
   //! appropriate instance method for processing.
   static void vreTdlTrackListCallback(DtSimMessage* msg, void* usr);
 
   //! \brief Processes tactical data link track list messages
   //! \param msg Pointer to the simulation message containing TDL track list data
   //!
   //! Processes tactical data link track list messages, which contain information
   //! about tracks shared over tactical data links such as Link 16.
   virtual void processVreTdlTrackList(DtSimMessage* msg);
 
   //! \brief Static callback for tactical data link engagement status messages
   //! \param msg Pointer to the simulation message containing TDL engagement status data
   //! \param usr Pointer to user data (typically the connector instance)
   //!
   //! Static callback function registered with the messaging system to receive
   //! tactical data link engagement status messages. Forwards the message to the
   //! appropriate instance method for processing.
   static void vreTdlEngagementStatusCallback(DtSimMessage* msg, void* usr);
 
   //! \brief Processes tactical data link engagement status messages
   //! \param msg Pointer to the simulation message containing TDL engagement status data
   //!
   //! Processes tactical data link engagement status messages, which contain
   //! information about weapon engagements shared over tactical data links.
   virtual void processVreTdlEngagementStatus(DtSimMessage* msg);
 
   //! \brief Static callback for interface load complete messages
   //! \param msg Pointer to the simulation message containing load complete data
   //! \param usr Pointer to user data (typically the connector instance)
   //!
   //! Static callback function registered with the messaging system to receive
   //! interface load complete messages. Forwards the message to the appropriate
   //! instance method for processing.
   static void ifLoadCompleteMessageCallback(DtSimMessage* msg, void* usr);
 
   //! \brief Processes interface load complete messages
   //! \param msg Pointer to the simulation message containing load complete data
   //!
   //! Processes messages indicating that a scenario has finished loading in the
   //! VR-Forces backend. This typically triggers follow-up actions such as
   //! verifying entity creation requests.
   virtual void processLoadCompleteMessage(DtSimMessage* msg);
 
public:
   //! \brief Static backend remapping callback
   //! \param map Pointer to the backend map to update
   //! \param expectedBackends Set of expected backend simulation addresses
   //! \param usr Pointer to user data (typically the connector instance)
   //! \return True if remapping was successful, false otherwise
   //!
   //! Static callback function used to remap backend addresses in the simulation.
   //! This is typically used when backend addresses change or when redirecting
   //! communication to different backends.
   static bool backendRemapper(DtBackendMap* map, const std::set<DtSimulationAddress>& expectedBackends, void* usr);
 
protected:
   //! \brief Remaps backend addresses for redirection
   //! \param map Pointer to the backend map to update
   //! \param expectedBackends Set of expected backend simulation addresses
   //! \return True if remapping was successful, false otherwise
   //!
   //! Updates the backend map to redirect communication to appropriate backend
   //! addresses. This is typically called when backend addresses change or when
   //! network topology is reconfigured.
   virtual bool remapBackends(DtBackendMap* map, const std::set<DtSimulationAddress>& expectedBackends);
 
   //! \brief Looks up reflected entity information by entity identifier
   //! \param entityId The entity identifier to search for
   //! \return Pointer to the reflected entity info, or NULL if not found
   //!
   //! Searches for and returns information about a reflected entity with the
   //! specified entity identifier. This provides access to essential entity
   //! information such as type, UUID, and marking text.
   virtual DtReflectedExtEntityInfo* lookupReflectedEntityInfo(const DtEntityIdentifier& entityId);
 
   //! \brief Looks up a UUID by entity identifier
   //! \param entityId The entity identifier to search for
   //! \return The UUID associated with the entity, or a null UUID if not found
   //!
   //! Retrieves the universally unique identifier (UUID) associated with the
   //! specified entity identifier. This is used to uniquely identify entities
   //! across distributed simulations.
   virtual DtUUID lookupUUID(const DtEntityIdentifier& entityId);
 
   //! \brief Finds a UUID for a reflected entity
   //! \param reflectedEntity Pointer to the reflected entity
   //! \return The UUID associated with the entity, or a null UUID if not found
   //!
   //! Retrieves the universally unique identifier (UUID) associated with the
   //! specified reflected entity object. This is used when only the entity object
   //! is available, not its identifier.
   //! \note Currently no easy accessor for this. TODO fix lookup for non-VRF simulated entities.
   virtual DtUUID findUUID(DtReflectedExtEntity* reflectedEntity);
 
   //! \brief Finds an entity identifier from a UUID
   //! \param uuid The UUID to search for
   //! \return The entity identifier associated with the UUID, or a null identifier if not found
   //!
   //! Performs the reverse lookup of lookupUUID, finding the entity identifier
   //! associated with a given universally unique identifier.
   virtual DtEntityIdentifier findEntityIdFromUUID(const DtUUID& uuid);
 
   //! \brief Sends interface content to the VR-Forces backend
   //! \param content The interface content to send
   //!
   //! Transmits interface content to the VR-Forces backend, which may include
   //! commands, queries, or data updates. This is a low-level method typically
   //! called by higher-level message handling methods.
   virtual void sendInterfaceContent(const DtSimInterfaceContent& content);
 
   //! \brief Control set management methods
   //! @{
 
   //! \brief Finds a control set for a specific entity
   //! \param entityId The entity identifier to search for
   //! \return Pointer to the found control set, or NULL if not found
   //!
   //! Searches for and returns the control set associated with the specified entity.
   //! A control set defines what capabilities are available for controlling the entity.
   virtual ControlSet* findControlSet(const DtEntityIdentifier& entityId);
 
   //! \brief Adds a new control set for an entity
   //! \param entityId The entity identifier to create a control set for
   //! \return Pointer to the newly created control set
   //!
   //! Creates and returns a new control set for the specified entity.
   //! This is typically called when an entity becomes available for control.
   virtual ControlSet* addControlSet(const DtEntityIdentifier& entityId);
 
   //! \brief Removes a control set for an entity
   //! \param entityId The entity identifier to remove the control set for
   //! \return True if the control set was found and removed, false otherwise
   //!
   //! Removes the control set associated with the specified entity.
   //! This is typically called when an entity is no longer available for control.
   virtual bool removeControlSet(const DtEntityIdentifier& entityId);
   //! @}
 
   //! \brief Status update methods
   //! @{
 
   //! \brief Updates the internal backend status information
   //!
   //! Retrieves and updates the current status of the VR-Forces backend,
   //! including connection state, load state, and operational parameters.
   virtual void updateBackendStatus();
 
   //! \brief Updates the internal session status information
   //!
   //! Retrieves and updates the current status of the simulation session,
   //! including play state, time, and active entities.
   virtual void updateSessionStatus();
 
   //! \brief Sends a message with current backend status
   //!
   //! Creates and sends a message containing the current backend status
   //! information to subscribed components.
   virtual void sendBackendStatusMessage();
 
   //! \brief Sends a message with current session status
   //!
   //! Creates and sends a message containing the current session status
   //! information to subscribed components.
   virtual void sendSessionStatusMessage();
 
   //! \brief Sends a message with the current session play state
   //!
   //! Creates and sends a message containing the current session play state
   //! (running, paused, or stopped) to subscribed components.
   virtual void sendSessionPlayState();
 
   //! \brief Sends a message with the current session SMS list
   //!
   //! Creates and sends a message containing the current list of simulation
   //! model sets (SMS) in the session to subscribed components.
   virtual void sendSessionSmsUpdate();
   //! @}
 
   //! \brief Entity creation and management methods
   //! @{
 
   //! \brief Verifies that a new ownship entity was created successfully
   //!
   //! Checks whether a previously requested ownship entity creation was successful.
   //! If the entity exists, it clears any pending creation flags. If the entity
   //! does not exist but should, it may trigger a new creation request.
   virtual void verifyNewOwnship();
 
   //! \brief Sends a request to create a new ownship entity
   //!
   //! Creates and sends a message requesting the creation of a new ownship entity
   //! in the simulation based on previously stored creation parameters.
   virtual void sendCreateNewOwnship();
 
   //! \brief Sends a request to delete an ownship entity
   //!
   //! Creates and sends a message requesting the deletion of a previously created
   //! ownship entity from the simulation.
   virtual void sendDeleteNewOwnship();
   //! @}
 
   //! \brief Checks if the VR-Engage backend exists
   //! \return True if the VRE backend exists, false otherwise
   //!
   //! Determines whether a VR-Engage backend is present in the simulation
   //! by checking for its simulation address.
   virtual bool doesVreBackendExist() const;
 
   //! \brief Calls virtual method of similar name when backend is discovered
   //! \return None
   static void BackendDiscovered(const DtSimulationAddress&, void* usr);
 
   //! \brief Adds to internal simulation addresses, and, if the backend we want to launch is
   //! using an already discovered address, change it
   //! \return None
   virtual void processBackendDiscovered(const DtSimulationAddress&);
 
   //! \brief Calls virtual method of similar name when backend is removed
   //! \return None
   static void BackendRemoved(const DtSimulationAddress&, void* usr);
 
   //! \brief Removes from internal simulation addresses
   //! \return None
   virtual void processBackendRemoved(const DtSimulationAddress&);
protected:
   //! \brief Pointer to the VRF message interface
   DtVrfMessageInterface* myVrfMessageInterface;
 
   //! \brief Pointer to the reflected extended entity list
   DtReflectedExtEntityList* myReflectedEntityList;
 
   //! \brief Pointer to the VRF remote controller
   makVrf::DtVrlinkVrfRemoteController* myVrfRemoteController;
 
   //! \brief Cached information about the last reflected entity lookup
   DtReflectedExtEntityInfo* myCachedReflectedEntityInfo;
 
   //! \brief Pointer to the reflected control object list
   DtReflectedControlObjectList* myReflectedControlObjectList;
 
   //! \brief Current session status data
   VrfSessionStatusMessage::VrfSessionStatusData mySessionStatus;
 
   //! \brief Flag indicating whether the session is playing
   bool mySessionIsPlaying;
 
   //! \brief Set of simulation model sets in the current session
   std::set<std::string> mySessionSmsList;
 
   //! \brief Simulation address of the VRE backend
   DtSimulationAddress myVreBackend;
   bool myTookSnapshot;
   double mySnapshotSimTime;
 
   //! \brief Initial simulation address used when starting the backend
   DtSimulationAddress myBackendStartingAddress;
 
   //! \brief Last known backend status data
   BackendStatusMessage::BackendStatusData myLastBackendStatus;
 
   //! \brief Flag indicating whether this backend is the hosting backend
   bool myBackendIsHost;
 
   //! \brief Message describing a new ownship entity to create
   CreateNewOwnshipMessage* myDesiredCreateEntityMessage;
 
   //! \brief Information about the created entity
   DtReflectedExtEntityInfo myCreatedEntityInfo;
 
   //! \brief Flag indicating whether we're waiting for an ownship to be deleted
   bool myWaitingForOwnshipDelete;
 
   //! \brief Flag indicating whether we're waiting for a new ownship to be created
   bool myWaitingForOwnshipCreate;
 
   //! \brief Flag indicating whether a newly created ownship needs repositioning
   bool myCreatedOwnshipNeedsReposition;
 
   //! \brief Current laser code for laser designation
   int myLaserCode;
 
   //! \brief Vector of control sets for managed entities
   std::vector<ControlSet*> myControlSets;
 
   //! \brief Last recorded wind speed
   double myLastWindSpeed;
 
   //! \brief Last recorded wind direction
   double myLastWindDirection;
 
   //! \brief Unique identifier for this connector instance
   unsigned int myId;
 
   //! \brief Cached waypoint target information
   //!
   //! Stores entity ID and position for waypoint targets which may not be
   //! displayed, so their position will need to be updated manually
   std::pair<DtEntityIdentifier, DtVector> myWaypointTarget;
 
   //! list of existing back-end address.  We will change our internal starting address if there
   //! is a similar one to prevent duplicates
   std::set<DtSimulationAddress> mySimulationAddresses;
};
} // namespace makVre