weaponFireConnector.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
******************************************************************************/
 
//! \file weaponFireConnector.h
//! \brief Defines the DtWeaponFireConnector class for handling weapon fire events
//!
//! This connector processes weapon fire events in the simulation, translating
//! between VR-Link fire interactions and VREngage fire messages.
 
#pragma once
 
#include "export.h"
 
#include "vrePlayerStationConnector/simEventConnector.h"
 
#include <vl/fireInteraction.h>
 
//! \brief Forward declaration of the exercise connection class
class DtExerciseConn;
 
//! \brief Forward declaration of the reflected entity list class
class DtReflectedEntityList;
 
//! \brief Forward declaration of the entity publisher class
class DtEntityPublisher;
 
//! \brief Forward declaration of the VRF message interface class
class DtVreVrfMsgInterface;
 
//! \brief Forward declaration of the simulation message class
class DtSimMessage;
 
 
namespace makVre
{
//! \brief Connector for handling weapon fire events in the simulation
//!
//! DtWeaponFireConnector processes weapon fire interactions from VR-Link and
//! translates them to VREngage fire messages. It also handles caching of fire
//! interactions when necessary entity information is not yet available.
class VRL_DLL DtWeaponFireConnector : public DT_PROTOCOL_NAMESPACE::DtSimEventConnector
{
public:
   //! \brief Default constructor
   //!
   //! Initializes the connector with name "WeaponFire"
   DtWeaponFireConnector();
 
   //! \brief Virtual destructor
   virtual ~DtWeaponFireConnector() override;
 
   //! \brief Installs the weapon fire connector with the application and connection
   //! \param app Pointer to the player station application
   //! \param connection Pointer to the protocol-specific VR-Link connection
   //!
   //! Calls the base class implementation, registers the fire callback,
   //! and retrieves the reflected entity list from the application
   virtual void install(
      DtPlayerStationApp* app, makVrv::DT_PROTOCOL_NAMESPACE::DtVrlinkConnection* connection) override;
 
   //! \brief Performs periodic processing of pending fire interactions
   //!
   //! Checks if any pending fire interactions are ready to send or have timed out,
   //! and processes them accordingly
   virtual void tick() override;
 
   //! \brief Shuts down the weapon fire connector
   //!
   //! Removes the fire callback from the connection
   virtual void shutdown() override;
 
   //! \brief Handles an incoming fire interaction
   //! \param fire Pointer to the fire interaction to process
   //!
   //! Either sends the fire message immediately if all necessary entity information
   //! is available, or caches it for later processing
   void handleFireMessage(DtFireInteraction* fire);
 
protected:
   //! \brief Finds the entity identifier for a global object designator
   //! \param globalId The global object designator to look up
   //! \return The entity identifier if found, or nullId if not found
   //!
   //! Looks up an entity in the reflected entity list by its global object designator
   DtEntityIdentifier findEntityId(const DtGlobalObjectDesignator& globalId);
 
   //! \brief Determines if a fire interaction is ready to be sent
   //! \param fire Pointer to the fire interaction to check
   //! \return True if the interaction is ready to send, false otherwise
   //!
   //! Makes sure that the firing entity and munition entity (if specified)
   //! have been discovered in the simulation
   bool fireMessageReadyToSend(DtFireInteraction* fire);
 
   //! \brief Sends a fire message for a fire interaction
   //! \param fire Pointer to the fire interaction to send
   //!
   //! Creates and queues a fire message with the information from the fire interaction
   void sendFireMessage(DtFireInteraction* fire);
 
protected:
   //! \brief Pointer to the reflected entity list
   //!
   //! Used to look up entities by their global object designators
   DtReflectedEntityList* myReflectedEntityList;
 
   //! \brief Type alias for pending fire interactions
   //!
   //! Each pair contains the timestamp when the interaction was received
   //! and a pointer to the fire interaction
   using PendingFireInteractions = std::vector<std::pair<double, DtFireInteraction*>>;
 
   //! \brief Cached fire interactions
   //!
   //! These interactions are delayed until the firing entity and munition entity
   //! have been discovered in the simulation
   PendingFireInteractions myPendingFireInteractions;
};
} // namespace makVre