radioLogic.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*****************************************************************************/
 
//! \file radioLogic.h
//! \brief Component for managing radio communications in the simulation
//! \ingroup vreCommonComponents
 
#pragma once
 
#include "vreCommonComponents/export.h"
#include "vrePlayerStation/playerComponent.h"
#include "vrePlayerStation/inputLogic.h"
 
#include "vreMessages/menuSetState.h"
 
#include <boost/function.hpp>
 
namespace makVre
{
class DtRadioEventProcessor;
class MenuActionMessage;
 
namespace RadioLogicConfig
{
//! \ingroup RoleConfigParams
//! \defgroup RadioLogicRoleParams Radio Logic Role Parameters
//! \roleInherits{PlayerComponentRoleParams}
//! Configuration Options for radio logic role.
//! @{
 
//! \vreRoleParam{defaultRadio,string,"",radioLogic,Name of the default radio to activate on startup.}
constexpr const char* defaultRadio = "defaultRadio";
 
//! \vreRoleParam{radios,table,"",radioLogic,Table of radio configurations with channel and crypto settings.}
constexpr const char* radios = "radios";
 
//! @}
} // namespace RadioLogicConfig
 
//! \brief Type identifier for DtRadioLogic component
constexpr const char* DtRadioLogicType = "DtRadioLogic";
 
//! \brief Component for managing radio communications in the simulation
//!
//! DtRadioLogic provides management of radio communication systems in the simulation,
//! handling radio channel selection, push-to-talk functionality, crypto settings,
//! and various radio modulation parameters. It supports both standard radios and
//! vehicle intercom systems, automatically managing radio state when embarking or
//! disembarking from vehicles. The component provides menu-driven controls for
//! switching between radios, channels, and communication settings.
class VRECOMMONCOMPONENTS_DLL DtRadioLogic : public makVre::DtPlayerComponent
{
public:
   //! \brief Enumeration for push-to-talk state
   //!
   //! Defines the possible states for the push-to-talk functionality
   enum PttState
   {
      PTT_ON, //!< Push-to-talk button is pressed, transmitting
      PTT_OFF //!< Push-to-talk button is released, not transmitting
   };
 
   //! \brief Constructor for DtRadioLogic
   //!
   //! Initializes the component with the name "DtRadioLogic" and sets up
   //! handlers for various radio menu actions
   DtRadioLogic();
 
   //! \brief Virtual destructor for DtRadioLogic
   virtual ~DtRadioLogic() override;
 
   //! \brief Initializes the radio logic component
   //! \param player Pointer to the player station this component belongs to
   //! \param config Configuration table containing radio settings
   //! \return True if initialization succeeded, false otherwise
   //!
   //! Sets up the radio manager, registers message handlers, and configures
   //! input handling for push-to-talk functionality. Also initializes the current
   //! radio based on saved state or configuration.
   virtual bool initialize(DtPlayerStation* player, DtInitTable& config) override;
   //! \brief Performs post-initialization after all components are initialized
   //! \return True if post-initialization succeeded, false otherwise
   //!
   //! Currently just returns true as no special post-initialization is needed
   virtual bool postInitialize() override;
 
   //! \brief Called every frame to update the component state
   //! \param dt Delta time since the last frame in seconds
   //!
   //! Current implementation is empty as updates occur through message handlers
   //! and attribute change callbacks
   virtual void tick(double dt) override {};
   //! \brief Shuts down the radio logic component
   //!
   //! Saves the current radio state to attributes for persistence, removes
   //! message handlers and callbacks, and shuts down the radio manager
   virtual void shutdown() override;
 
   //! \brief Returns the type identifier for this component
   //! \return The type string for DtRadioLogic
   virtual const char* type() const override;
 
   //! \brief Sets the push-to-talk state for the current radio
   //! \param state The desired PTT state (on or off)
   //!
   //! Activates or deactivates transmission on the current radio based on
   //! the specified PTT state. Does nothing if no radio is selected.
   virtual void ptt(PttState state);
 
 
protected:
   //! \brief Initializes state attributes for radio communication
   //!
   //! Current implementation is empty as attributes are initialized elsewhere
   virtual void initializeStateAttributes() override;
 
   //! \brief Handles menu messages related to radio operations
   //! \param msg The menu message to process
   //! \return Message handling result indicating the message was handled
   //!
   //! Routes menu action messages to the appropriate handler based on the action type
   DtVreMessageResult handleRadioMenuMessage(DtVreMessage* msg);
 
   //! \brief Handles changes to the player's embarked state
   //! \param val Entity identifier of the vehicle being embarked on, or null if disembarking
   //!
   //! Manages vehicle intercom system when embarking on or disembarking from vehicles
   void handleEmbarkedOnChanged(DtEntityIdentifier val);
 
   //! \brief Updates the radio manager based on current radio state
   //!
   //! Ensures only the current radio is powered on, manages audio capture settings,
   //! and configures push-to-talk functionality based on radio state
   void updateRadioManager();
 
   //! \brief Updates state attributes with current radio settings
   //!
   //! Stores all current radio parameters (current radio, channel, crypto settings, etc.)
   //! to the player attribute store for UI display and persistence
   void updateAttributes();
 
   //! \brief Handles push-to-talk input events
   //! \param val Input value (1.0 for pressed, 0.0 for released)
   //!
   //! Translates input values to PTT states and calls the ptt() function
   void handlePushToTalk(float val);
 
   //! \brief Sets the current radio to a specific index
   //! \param msg Menu message containing the radio index as a parameter
   void handleSetRadio(MenuActionMessage* msg);
 
   //! \brief Cycles to the next available radio or turns off if at the last radio
   //! \param msg Menu message triggering the action
   void handleCycleRadio(MenuActionMessage* msg);
 
   //! \brief Cycles to the next channel on the current radio
   //! \param msg Menu message triggering the action
   void handleCycleChannel(MenuActionMessage* msg);
 
   //! \brief Cycles through available duplex modes (FULL/HALF)
   //! \param msg Menu message triggering the action
   void handleCycleDuplex(MenuActionMessage* msg);
 
   //! \brief Cycles through available cryptographic systems
   //! \param msg Menu message triggering the action
   void handleCycleCryptoSystem(MenuActionMessage* msg);
 
   //! \brief Sets the crypto key based on input from a menu
   //! \param msg Menu message containing the crypto key as a parameter
   void handleCryptoKeyInput(MenuActionMessage* msg);
 
   //! \brief Cycles through available cryptographic modes
   //! \param msg Menu message triggering the action
   void handleCycleCryptoMode(MenuActionMessage* msg);
 
   //! \brief Cycles through available modulation system types
   //! \param msg Menu message triggering the action
   void handleCycleModulationSystem(MenuActionMessage* msg);
 
   //! \brief Cycles through available major modulation types
   //! \param msg Menu message triggering the action
   void handleCycleModulationMajor(MenuActionMessage* msg);
 
   //! \brief Cycles through available modulation detail types
   //! \param msg Menu message triggering the action
   void handleCycleModulationDetail(MenuActionMessage* msg);
 
   //! \brief Toggles frequency hopping on/off
   //! \param msg Menu message triggering the action
   void handleCycleFrequencyHopping(MenuActionMessage* msg);
 
   //! \brief Toggles time hopping on/off
   //! \param msg Menu message triggering the action
   void handleCycleTimeHopping(MenuActionMessage* msg);
 
   //! \brief Toggles pseudo-noise on/off
   //! \param msg Menu message triggering the action
   void handleCyclePseudoNoise(MenuActionMessage* msg);
 
   //! \brief Gets the name of the current radio
   //! \return Name of the current radio or "OFF" if no radio is selected
   std::string currentRadioName();
 
   //! \brief Gets the channel name of the current radio
   //! \return Channel name with frequency information or placeholder if not applicable
   std::string currentChannelName();
 
   //! \brief Gets the duplex mode of the current radio
   //! \return Duplex mode as a string or placeholder if no radio selected
   std::string currentDuplex();
 
   //! \brief Gets the cryptographic system of the current radio
   //! \return Crypto system name or "OTHER" if no radio/channel selected
   std::string currentCryptoSystem();
 
   //! \brief Gets the cryptographic key of the current radio
   //! \return Crypto key as a string or "0" if no radio/channel selected
   std::string currentCryptoKey();
 
   //! \brief Gets the cryptographic mode of the current radio
   //! \return Crypto mode as a string or empty if no radio/channel selected
   std::string currentCryptoMode();
 
   //! \brief Gets the modulation system of the current radio
   //! \return Modulation system as a string or empty if no radio/channel selected
   std::string currentModulationSystem();
 
   //! \brief Gets the major modulation type of the current radio
   //! \return Major modulation type as a string or empty if no radio/channel selected
   std::string currentModulationMajor();
 
   //! \brief Gets the modulation detail type of the current radio
   //! \return Modulation detail as a string or empty if no radio/channel selected
   std::string currentModulationDetail();
 
   //! \brief Gets the frequency hopping state of the current radio
   //! \return "ON" or "OFF" as a string or empty if no radio/channel selected
   std::string currentFrequencyHopping();
 
   //! \brief Gets the time hopping state of the current radio
   //! \return "ON" or "OFF" as a string or empty if no radio/channel selected
   std::string currentTimeHopping();
 
   //! \brief Gets the pseudo-noise state of the current radio
   //! \return "ON" or "OFF" as a string or empty if no radio/channel selected
   std::string currentPseudoNoise();
 
   //! \brief Sets the cryptographic key for the current radio
   //! \param cryptoKey The crypto key value to set
   //!
   //! Updates the crypto key of the current radio if one is selected
   void setCryptoKey(unsigned short cryptoKey);
 
   //! \brief Index of the currently selected radio (-1 if no radio selected)
   int myCurrentRadio;
 
   //! \brief Input logic for handling push-to-talk and other input actions
   DtInputLogic myInputLogic;
 
   //! \brief Map of menu action names to handler functions
   //!
   //! Used to dispatch menu action messages to the appropriate handler methods
   std::map<std::string, boost::function<void(DtRadioLogic*, MenuActionMessage*)>> myMenuActionMessageFnMap;
 
   //! \brief Connection made to de post tick to tick the radio manager
   boost::signals2::connection myRadioManagerTickConnection;
 
   // Commented out attributes - likely moved to using the attribute store directly
   // instead of keeping local attribute pointers
   // DtAttribute<std::string>* myCurrentRadioAttr;
   // DtAttribute<std::string>* myCurrentChannelAttr;
   // DtAttribute<DtEntityIdentifier>* myEmbarkedOnAttr;
 
   DtEntityIdentifier myPreviouslyEmbarkedOn;
};
 
} // namespace makVre