vreLauncherActuator.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
 
//! \file vreLauncherActuator.h
//! \ingroup vreVrfmodel
//! \brief Actuator for missile launcher systems
//!
//! This file defines the DtVreLauncherActuator class which extends VR-Forces'
//! DtLauncherActuator to fire specialized missiles such as the FGM-148 Javelin.
//! It manages attack mode state and passes it as part of the creation parameters
//! when creating a missile.
#pragma once
 
#include "vreVrfmodel/export.h"
 
#include <vrfmodel/launcherActuator.h>
 
 
namespace makVre
{
//! \brief Type identifier for the VRE launcher actuator component
const char DtVreLauncherActuatorType[] = "vre-launcher-actuator";
 
class DtTopAndDirectLauncherPSR;
 
//! \brief Actuator for missile launcher systems with mode-aware functionality
//!
//! DtVreLauncherActuator extends the base launcher actuator to provide specialized
//! missile firing capabilities, particularly for systems like the FGM-148 Javelin.
//! It maintains the attack mode state of the launcher (e.g., direct attack or
//! top attack modes) and passes this state as part of the creation parameters
//! when instantiating a missile. This allows the missile to behave according to
//! the selected attack mode.
class VREVRFMODEL_DLL DtVreLauncherActuator : public DtLauncherActuator
{
public:
   //! \brief Constructor
   //! \param name The name of this component
   //! \param owner The local object that owns this component
   //! \param simManager The simulation services manager
   //! \param desc Component descriptor with configuration parameters
   //! \param parentRegistry Optional parent registry for reader/writer functionality
   //!
   //! Creates a new launcher actuator component with the specified parameters.
   DtVreLauncherActuator(const DtString& name, DtLocalObject* owner, DtSimulationServices* simManager,
      DtComponentDescriptor* desc = 0, DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Virtual destructor
   //!
   //! Cleans up resources used by the launcher actuator component.
   virtual ~DtVreLauncherActuator() override;
 
   //! \brief Gets the type identifier for this component
   //! \return String identifying the component type (DtVreLauncherActuatorType)
   //!
   //! Implements the DtSimComponent::type() method to return the
   //! type identifier for this component.
   virtual const char* type() const override;
 
   //! \brief Performs initialization before the first simulation tick
   //!
   //! Sets the missile attack mode in extended data from the process state repository.
   //! This ensures that the attack mode is properly initialized before the
   //! simulation begins, allowing missiles to be created with the correct parameters.
   virtual void preFirstTickInit() override;
 
   //! Overridden to add setting <systemName>.current-munition
   virtual void tick() override;
 
   //! Called before writing this object out to a file. Gets the current value
   //! of "attackMode" from extended data and saves it to the process state repository
   //! before writing it out. This ensures that the attack mode state is properly
   //! preserved when the scenario is saved.
   virtual void prePutSelf() override;
 
   //! @brief Overridden to use the muzzle offset from the descriptor. Base class function isn't working.
   //! @return muzzle offset in local coordinates.
   virtual DtVector muzzleLocalPosition() override;
 
   //! \brief Factory method to create a new instance of this component
   //! \param name The name for the new component
   //! \param owner The local object that will own this component
   //! \param simManager The simulation services manager
   //! \param desc Optional component descriptor
   //! \param parentRegistry Optional parent registry for reader/writer functionality
   //! \return Pointer to the newly created component
   //!
   //! Static factory method used by the component creation system to instantiate
   //! new instances of this component type.
   static DtSimComponent* creator(const DtString& name, DtLocalObject* owner, DtSimulationServices* simManager,
      DtComponentDescriptor* desc = 0, DtReaderWriterRegistry* parentRegistry = 0);
 
protected:
   //! \brief Creates the process state repository for the actuator
   //! \return True if PSR creation is successful, false otherwise
   //!
   //! Overrides the base class implementation to create and cache a pointer
   //! to the derived type of process state repository (DtJavelinLauncherPSR).
   //! This allows direct access to Javelin-specific state information.
   virtual bool createPSR() override;
 
   //! \brief Creates a missile object with the appropriate attack mode
   //! \param createdInfo Information about the object to be created
   //! \return Handle to the created missile object
   //!
   //! Overrides the base class implementation to pass the current attackMode
   //! extended state parameter as a creation parameter for the missile. This
   //! allows the missile to be created with the correct attack mode (e.g., direct
   //! attack or top attack for Javelin missiles).
   virtual DtCreateObjectHandle createMissile(DtVrfLocalObjectCreateInformation& createdInfo) override;
 
protected:
   //! \brief Default constructor (not implemented)
   //!
   //! Default constructor is protected and not implemented to prevent
   //! creation of instances without proper initialization.
   DtVreLauncherActuator();
 
   //! \brief Copy constructor (not implemented)
   //!
   //! Copy constructor is protected and not implemented to prevent
   //! copy construction.
   DtVreLauncherActuator(const DtVreLauncherActuator& orig);
 
   //! \brief Assignment operator (not implemented)
   //! \return Reference to this object
   //!
   //! Assignment operator is protected and not implemented to prevent assignment.
   const DtVreLauncherActuator& operator=(const DtVreLauncherActuator& orig);
 
protected:
   //! \brief Pointer to the Missile launcher process state repository
   //!
   //! Stores a typed pointer to the process state repository for more efficient
   //! access to missile-specific state data such as attack mode. This allows
   //! the actuator to directly access and modify state without type casting.
   DtTopAndDirectLauncherPSR* myLauncherPSR;
};
} // namespace makVre