vreAmmunitionParamsEntry.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file vreAmmunitionParamsEntry.h
//! \ingroup vreVrfobjparam
//! \brief Ammunition parameter entry for VREngage
//!
//! This file defines the DtVreAmmunitionParamsEntry class, which represents
//! a single ammunition type entry in VREngage's ammunition parameter database.
//! It provides ballistic properties and load time configuration for ammunition.
 
#pragma once
#include <vreVrfobjparam/export.h>
 
#include <vrfobjparam/ammunitionParamsEntry.h>
#include <vrfUtil/rwTemplatedList.h>
 
namespace makVre
{
//! \brief Ammunition parameter entry for VREngage weapon systems
//!
//! The DtVreAmmunitionParamsEntry contains fields loaded from ammunitionParams.mtl
//! via DtVreAmmunitionManager. It stores physical and ballistic properties of ammunition,
//! including cross-section, drag coefficient, mass, and load time.
class VREVRFOBJPARAM_DLL DtVreAmmunitionParamsEntry : public DtAmmunitionParamsEntry
{
public:
   //! \brief Templated list type for ammunition parameter entries
   //!
   //! This type defines a reader/writer templated list of ammunition parameter entries
   //! with automatic memory management (pointer ownership).
   using DtVreAmmunitionParamsEntryList = DtRwTemplatedListPtr<DtVreAmmunitionParamsEntry*, true>;
 
   //! \brief Constructor with entry name
   //! \param name The name of this ammunition entry
   //! \param parentRegistry Parent registry for reader/writer functionality (optional)
   //!
   //! Creates a new ammunition parameter entry with the specified name.
   DtVreAmmunitionParamsEntry(const DtString& name, DtReaderWriterRegistry* parentRegistry = NULL);
 
   //! \brief Constructor with entry name as symbol string
   //! \param name The name of this ammunition entry as a symbol string
   //! \param parentRegistry Parent registry for reader/writer functionality (optional)
   //!
   //! Creates a new ammunition parameter entry with the specified name.
   DtVreAmmunitionParamsEntry(const DtSymbolString& name, DtReaderWriterRegistry* parentRegistry = NULL);
 
   //! \brief Virtual destructor
   //!
   //! Cleans up resources used by the ammunition parameter entry.
   virtual ~DtVreAmmunitionParamsEntry() override;
 
   //! \brief Copy constructor with name
   //! \param name The name for the new entry
   //! \param orig The source entry to copy from
   //! \param parentRegistry Parent registry for reader/writer functionality (optional)
   //!
   //! Creates a new ammunition parameter entry as a copy of the provided original.
   DtVreAmmunitionParamsEntry(
      const DtString& name, const DtVreAmmunitionParamsEntry& orig, DtReaderWriterRegistry* parentRegistry = NULL);
 
   //! \brief Copy constructor with name as symbol string
   //! \param name The name for the new entry as a symbol string
   //! \param orig The source entry to copy from
   //! \param parentRegistry Parent registry for reader/writer functionality (optional)
   //!
   //! Creates a new ammunition parameter entry as a copy of the provided original.
   DtVreAmmunitionParamsEntry(const DtSymbolString& name, const DtVreAmmunitionParamsEntry& orig,
      DtReaderWriterRegistry* parentRegistry = NULL);
 
   //! \brief Assignment operator
   //! \param orig The source entry to copy from
   //! \return Reference to this entry after assignment
   //!
   //! Assigns the contents of the provided entry to this one.
   DtVreAmmunitionParamsEntry& operator=(const DtVreAmmunitionParamsEntry& orig);
 
   //! \brief Creates a clone of this entry
   //! \param parent Parent registry for reader/writer functionality (optional)
   //! \return Pointer to a new entry that is a clone of this one
   //!
   //! Creates a new ammunition parameter entry as a deep copy of this one.
   virtual DtVreAmmunitionParamsEntry* clone(DtReaderWriterRegistry* parent = 0) const override;
 
   //! \brief Equality operator
   //! \param other The entry to compare with
   //! \return True if the entries are equal, false otherwise
   //!
   //! Compares this entry with another to determine if they are equal.
   bool operator==(const DtVreAmmunitionParamsEntry& other) const;
 
   //! \brief Inequality operator
   //! \param rhs The entry to compare with
   //! \return True if the entries are not equal, false otherwise
   //!
   //! Compares this entry with another to determine if they are not equal.
   bool operator!=(const DtVreAmmunitionParamsEntry& rhs) { return !(*this == rhs); }
 
   //! \name Ammunition Properties
   //! @{
 
   //! \brief Gets the cross-section of the projectile
   //! \return The cross-section (diameter) of the projectile
   //!
   //! Returns the cross-sectional diameter of the projectile, which affects
   //! its ballistic trajectory and impact characteristics.
   double crossSection() const { return myCrossSection; }
 
   //! \brief Sets the cross-section of the projectile
   //! \param crossSection The cross-section (diameter) of the projectile
   //!
   //! Sets the cross-sectional diameter of the projectile, which affects
   //! its ballistic trajectory and impact characteristics.
   virtual void setCrossSection(double crossSection) { myCrossSection = crossSection; }
 
   //! \brief Gets the drag coefficient of the projectile
   //! \return The drag coefficient value
   //!
   //! Returns the drag coefficient of the projectile, which determines
   //! how much air resistance affects its flight path.
   double dragCoefficient() const { return myDragCoefficient; }
 
   //! \brief Sets the drag coefficient of the projectile
   //! \param dragCoefficient The drag coefficient value
   //!
   //! Sets the drag coefficient of the projectile, which determines
   //! how much air resistance affects its flight path.
   virtual void setDragCoefficient(double dragCoefficient) { myDragCoefficient = dragCoefficient; }
 
   //! \brief Gets the mass of the projectile
   //! \return The mass of the projectile in kilograms
   //!
   //! Returns the mass of the projectile in kilograms, which affects
   //! its ballistic trajectory, range, and impact force.
   double projectileMass() const { return myProjectileMass; }
 
   //! \brief Sets the mass of the projectile
   //! \param projectileMass The mass of the projectile in kilograms
   //!
   //! Sets the mass of the projectile in kilograms, which affects
   //! its ballistic trajectory, range, and impact force.
   virtual void setProjectileMass(double projectileMass) { myProjectileMass = projectileMass; }
 
   //! \brief Gets the loading time for this ammunition
   //! \return The loading time in seconds
   //!
   //! Returns the time required to load this ammunition type into a weapon,
   //! which affects weapon rate of fire and tactical considerations.
   double loadTime() const { return myLoadTime; }
 
   //! \brief Sets the loading time for this ammunition
   //! \param loadTime The loading time in seconds
   //!
   //! Sets the time required to load this ammunition type into a weapon,
   //! which affects weapon rate of fire and tactical considerations.
   virtual void setLoadTime(double loadTime) { myLoadTime = loadTime; }
 
   //! @}
 
protected:
   //! \brief The cross-section (diameter) of the projectile
   //!
   //! Affects the projectile's ballistic trajectory and impact characteristics.
   DtRwReal myCrossSection;
 
   //! \brief The drag coefficient of the projectile
   //!
   //! Determines how much air resistance affects the projectile's flight path.
   DtRwReal myDragCoefficient;
 
   //! \brief The mass of the projectile in kilograms
   //!
   //! Affects the projectile's ballistic trajectory, range, and impact force.
   DtRwReal myProjectileMass;
 
   //! \brief The time required to load this ammunition in seconds
   //!
   //! Determines how quickly this ammunition type can be loaded into a weapon.
   DtRwReal myLoadTime;
};
} // namespace makVre