topAndDirectMissileFlightPSR.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file topAndDirectMissileFlightPSR.h
//! \ingroup vreVrfobjcore
//! \brief Javelin missile flight process state repository for VREngage
//!
//! This file defines the DtJavelinMissileFlightPSR class, which provides a process state repository
//! for Javelin missile flight components in VREngage. It extends the base missile flight PSR
//! with Javelin-specific flight phases, attack modes, and starting location.
 
#pragma once
 
#include "vreVrfobjcore/export.h"
 
#include <vrfobjcore/missileFlightPSR.h>
 
namespace makVre
{
const char DtTopAndDirectMissileFlightPSRType[] = "top-and-direct-missile-flight-PSR";
 
//! class DtTopAndDirectMissileFlightPSR:
//!
//! Instances of DtTopAndDirectMissileFlightPSR are
//!
//! Instances of DtTopAndDirectMissileFlightPSR are used to hold the shared/checkpointable
//! state data associated with the process of missile flight.  Extended to
//! include the concept of phases of flight for the missile.
 
class VREVRFOBJCORE_DLL DtTopAndDirectMissileFlightPSR : public DtMissileFlightPSR
{
public:
   //! \brief Constructor with VRF object and optional name
   //! \param vrfObject Pointer to the local object this PSR is associated with
   //! \param rwName Optional reader/writer name
   //! \param parentRegistry Optional parent registry for reader/writer functionality
   //!
   //! Creates a new Javelin missile flight PSR for the specified VRF object.
   DtTopAndDirectMissileFlightPSR(DtLocalObject* vrfObject, const DtString& rwName = DtString::nullString(),
      DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Copy constructor
   //! \param orig The source PSR to copy from
   //! \param rwName Optional reader/writer name
   //! \param parentRegistry Optional parent registry for reader/writer functionality
   //!
   //! Creates a new Javelin missile flight PSR as a copy of the provided original.
   DtTopAndDirectMissileFlightPSR(const DtTopAndDirectMissileFlightPSR& orig,
      const DtString& rwName = DtString::nullString(), DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Virtual destructor
   //!
   //! Cleans up resources used by the PSR.
   virtual ~DtTopAndDirectMissileFlightPSR() override;
 
   //! \brief Assignment operator (not implemented)
   //! \param orig The source PSR to copy from
   //! \return Reference to this PSR after assignment
   //!
   //! Assignment operator is declared but may not be fully implemented.
   DtTopAndDirectMissileFlightPSR& operator=(const DtTopAndDirectMissileFlightPSR& orig);
 
   //! \brief Creates a clone of this PSR
   //! \param rwName Optional reader/writer name for the clone
   //! \param parentRegistry Optional parent registry for reader/writer functionality
   //! \return Pointer to a new PSR that is a clone of this one
   //!
   //! Creates a new Javelin missile flight PSR as a deep copy of this one.
   virtual DtVrfProcessStateRepository* clone(const DtString& rwName = DtString::nullString(),
      DtReaderWriterRegistry* parentRegistry = 0) const override;
 
   //! Returns the string type of the repository,
   //! (DtTopAndDirectMissileFlightProcessStateRepositoryType).
   virtual DtString type() const override;
 
   //! \brief Sets the missile flight phase
   //! \param phase The flight phase to set
   //!
   //! Sets the current flight phase of the Javelin missile.
   //! Javelin missiles typically go through several flight phases including
   //! launch, motor burn, coast, terminal guidance, etc.
   virtual void setFlightPhase(const DtString& phase);
 
   //! \brief Gets the missile flight phase
   //! \return String identifying the current flight phase
   //!
   //! Returns the current flight phase of the Javelin missile.
   virtual DtString flightPhase() const;
 
   //! \brief Sets the missile attack mode
   //! \param mode The attack mode to set ("top" for top attack, "direct" for direct attack)
   //!
   //! Sets the attack mode for the Javelin missile.
   //! Top attack mode causes the missile to fly a high arc to impact the target from above,
   //! while direct attack mode flies a more direct path to the target.
   virtual void setAttackMode(const DtString& mode);
 
   //! \brief Gets the missile attack mode
   //! \return String identifying the current attack mode ("top" or "direct")
   //!
   //! Returns the current attack mode of the Javelin missile.
   virtual DtString attackMode() const;
 
   //! \brief Sets the missile starting location
   //! \param location The starting location in geocentric coordinates
   //!
   //! Sets the starting location of the missile in geocentric coordinates.
   //! This is used for various flight calculations and trajectory planning.
   virtual void setStartingLocation(const DtVector& location);
 
   //! \brief Gets the missile starting location
   //! \return The starting location in geocentric coordinates
   //!
   //! Returns the starting location of the missile in geocentric coordinates.
   virtual const DtVector& startingLocation() const;
 
   //! \brief Factory function to create a new instance of this PSR
   //! \param rwName The reader/writer name for the new instance
   //! \param vrfObject Pointer to the local object this PSR will be associated with
   //! \param parentRegistry Parent registry for reader/writer functionality
   //! \return Pointer to a newly created PSR instance
   //!
   //! Static factory function used by the PSR creation system to instantiate
   //! new instances of this PSR type.
   static DtVrfProcessStateRepository* creator(
      const DtString& rwName, DtLocalObject* vrfObject, DtReaderWriterRegistry* parentRegistry);
 
protected:
   //! Flight phase (used by the missile).
   DtRwString myFlightPhase;
 
   //! \brief The missile attack mode
   //!
   //! Stores the attack mode for the Javelin missile ("top" or "direct").
   //! Top attack mode causes the missile to fly a high arc to impact the target from above,
   //! while direct attack mode flies a more direct path to the target.
   DtRwString myAttackMode;
 
   //! \brief The missile starting location
   //!
   //! Stores the starting location of the missile in geocentric coordinates.
   //! This is used for various flight calculations and trajectory planning.
   DtRwVector myStartingLocation;
};
} // namespace makVre