setVreControlled.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file setVreControlled.h
//! \ingroup vreVrfMessages
//! \brief VREngage control state request message
//!
//! This file defines the DtSetVreControlledRequest class, which is used to set the
//! VREngage control state of an entity, including which roles are controlled, in the
//! VRForces back-end simulation.
 
#pragma once
 
#include "vreVrfMessages/export.h"
#include <vrftasks/setDataRequest.h>
#include <vrfutil/rwSimulationAddress.h>
#include <readerWriter/rwBoolean.h>
#include <readerWriter/rwString.h>
#include <vrftasks/radioMessageTypes.h>
 
namespace makVre
{
//! \brief Message type for VREngage control state requests
//!
//! Unique identifier for the set-vre-controlled message type used in the factory system.
//! This must be a unique string to distinguish from other set types defined in msgTypes.h.
const DtSetMessageType DtSetVreControlledType("set-vre-controlled");
 
//! \brief Request to set the VREngage control state of an entity
//!
//! This class is used to inform a VRForces back-end that an entity is being controlled
//! by a VREngage player station. The message includes the identity of the controlling
//! application, station information, and role information (e.g., gunner, driver,
//! commander, or entity-level control).
class VRFMESSAGES_DLL DtSetVreControlledRequest : public DtSetDataRequest
{
public:
   //! \brief Default constructor
   //!
   //! Initializes an empty VREngage control state request.
   DtSetVreControlledRequest();
 
   //! \brief Named constructor for reader/writer functionality
   //! \param writeName The name to identify this request
   //! \param parentRegistry Optional reader-writer registry for serialization
   //!
   //! If you have a request 'put' itself, the writeName will preface it.
   DtSetVreControlledRequest(const DtString& writeName, DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Copy constructor
   //! \param writeName The name to identify this request
   //! \param orig The request to copy from
   //! \param parentRegistry Optional reader-writer registry for serialization
   //!
   //! Creates a new request by copying an existing one.
   DtSetVreControlledRequest(
      const DtString& writeName, const DtSetVreControlledRequest& orig, DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Assignment operator
   //! \param orig The request to copy from
   //! \return Reference to this object after assignment
   //!
   //! Copies the contents of another request into this one.
   const DtSetVreControlledRequest& operator=(const DtSetVreControlledRequest& orig);
 
   //! \brief Virtual destructor
   virtual ~DtSetVreControlledRequest() override;
 
   //! \brief Gets the message type
   //! \return The message type identifier
   //!
   //! Returns DtSetVreControlledType as the message type identifier.
   virtual const DtSetMessageType& type() const override;
 
   //! \brief Creates a copy of this request
   //! \param name The name to identify the cloned request
   //! \param parentRegistry Optional reader-writer registry for serialization
   //! \return Pointer to a new dynamically allocated copy
   //!
   //! Creates a deep copy of the request for factory system use.
   virtual DtSetDataRequest* clone(const DtString& name, DtReaderWriterRegistry* parentRegistry = 0) const override;
 
   //! \brief Gets a human-readable string representation
   //! \return String containing a human-readable representation of the request
   //!
   //! Provides a human-readable representation of this request for debugging and logging.
   virtual DtString stringRep() const override;
 
   //! \brief Gets the simulation address of the player station
   //! \return The simulation address of the controlling player station
   //!
   //! Returns the simulation address of the VREngage player station that is
   //! controlling the entity.
   virtual DtSimulationAddress simulationAddress() const;
 
   //! \brief Sets the simulation address of the player station
   //! \param address The simulation address to set
   //!
   //! Sets the simulation address of the VREngage player station that is
   //! controlling the entity.
   virtual void setSimulationAddress(const DtSimulationAddress& address);
 
   //! \brief Gets the published ID of the player station
   //! \return The unique ID of the controlling player station
   //!
   //! Returns the unique identifier for the VREngage player station that is
   //! controlling the entity.
   virtual unsigned stationId() const;
 
   //! \brief Sets the published ID of the player station
   //! \param id The unique ID to set
   //!
   //! Sets the unique identifier for the VREngage player station that is
   //! controlling the entity.
   virtual void setStationId(unsigned id);
 
   //! \brief Gets the published name of the player station
   //! \return The name of the controlling player station
   //!
   //! Returns the name of the VREngage player station that is controlling the entity.
   virtual std::string stationName() const;
 
   //! \brief Sets the published name of the player station
   //! \param name The station name to set
   //!
   //! Sets the name of the VREngage player station that is controlling the entity.
   virtual void setStationName(const std::string& name);
 
   //! \brief Gets the player station control state
   //! \return True if the entity is player station controlled, false otherwise
   //!
   //! Returns whether the entity is currently controlled by a VREngage player station.
   virtual bool playerStationControlled() const;
 
   //! \brief Sets the player station control state
   //! \param trueFalse True to enable player station control, false to disable
   //!
   //! Sets whether the entity is controlled by a VREngage player station.
   //! When set to false, this can be used to release control back to AI.
   virtual void setPlayerStationControlled(bool trueFalse);
 
   //! \brief Gets the controlled roles for the entity
   //! \return List of role strings indicating which stations are controlled
   //!
   //! Returns a list of strings indicating which roles/stations are controlled
   //! by the VREngage player station, such as "gunner", "driver", "commander",
   //! or "entity" for entity-level control.
   virtual std::vector<std::string> roles() const;
 
   //! \brief Sets the controlled roles for the entity
   //! \param description List of role strings indicating which stations are controlled
   //!
   //! Sets the list of strings indicating which roles/stations are controlled
   //! by the VREngage player station, such as "gunner", "driver", "commander",
   //! or "entity" for entity-level control.
   virtual void setRoles(const std::vector<std::string>& description);
 
   //! \brief Gets the network representation size
   //! \return Size in bytes of the network representation
   //!
   //! Returns the size of the network buffer needed to store this request,
   //! padded to an 8-byte boundary for alignment.
   virtual int netRepSize() const override;
 
   //! \brief Deserializes the request from a network buffer
   //! \param contentBuffer Pointer to the network buffer
   //! \param contentSize Size of the buffer in bytes
   //! \return True if deserialization was successful
   //!
   //! Fills the request from the provided network buffer.
   virtual bool setFromNet(const char* contentBuffer, unsigned contentSize) override;
 
   //! \brief Serializes the request for network transmission
   //! \return True if serialization was successful
   //!
   //! Fills in the network buffer (created by base class setDataRequest) with
   //! the request contents for transmission.
   virtual bool setToNet() override;
 
   //! \brief Static creator function for factory registration
   //! \return Pointer to a new instance of DtSetVreControlledRequest
   //!
   //! This static function is used for registration with the request factory system.
   static DtSetDataRequest* creator();
 
protected:
   //! \brief Simulation address of the controlling player station
   DtRwSimulationAddress mySimulationAddress;
 
   //! \brief Unique identifier for the controlling player station
   DtRwUnsigned myStationId;
 
   //! \brief Name of the controlling player station
   DtRwString myStationName;
 
   //! \brief Flag indicating whether the entity is player station controlled
   DtRwBoolean myIsPlayerStationControlled;
 
   //! \brief List of roles/stations that are controlled
   //!
   //! Contains strings like "gunner", "driver", "commander", or "entity".
   DtRwStringList myRoles;
};
} // namespace makVre