ammoLoadTime.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file ammoLoadTime.h
//! \ingroup vreVrfobjparam
//! \brief Ammunition loading time parameter definitions for VREngage
//!
//! This file defines the DtAmmoLoadTime class and DtAmmoLoadTimeList type,
//! which store ammunition type names and their corresponding load times for weapons.
//! These parameters enable realistic weapon reload timing in VREngage simulations.
 
#pragma once
 
#include "vreVrfobjparam/export.h"
 
#include <vrfutil/rwTemplatedList.h>
 
#include <readerWriter/rwReal.h>
 
namespace makVre
{
//! \brief Type identifier string for DtAmmoLoadTime class
const char DtAmmoLoadTimeType[] = "DtAmmoLoadTime";
 
//! \brief Ammunition loading time parameter class for VREngage weapons
//!
//! This class defines the loading time parameters for specific ammunition types
//! used by weapons in VREngage. It allows for realistic simulation of weapon
//! reloading times based on ammunition type, enhancing combat simulation fidelity.
class VREVRFOBJPARAM_DLL DtAmmoLoadTime : public DtReaderWriter
{
public:
   //! \brief Default constructor
   //!
   //! Creates a new ammunition loading time parameter with default values.
   DtAmmoLoadTime();
 
   //! \brief Constructor with ammunition name
   //! \param name The name of the ammunition type
   //! \param parentRegistry Parent registry for reader/writer functionality (optional)
   //!
   //! Creates a new ammunition loading time parameter for the specified ammunition type.
   DtAmmoLoadTime(const DtString& name, DtReaderWriterRegistry* const parentRegistry = NULL);
 
   //! \brief Constructor with ammunition name as symbol string
   //! \param name The name of the ammunition type as a symbol string
   //! \param parentRegistry Parent registry for reader/writer functionality (optional)
   //!
   //! Creates a new ammunition loading time parameter for the specified ammunition type.
   DtAmmoLoadTime(const DtSymbolString& name, DtReaderWriterRegistry* const parentRegistry = NULL);
 
   //! \brief Virtual destructor
   //!
   //! Cleans up resources used by the ammunition loading time parameter.
   virtual ~DtAmmoLoadTime() override;
 
   //! \brief Copy constructor
   //! \param orig The source object to copy from
   //! \param parentRegistry Parent registry for reader/writer functionality (optional)
   //!
   //! Creates a new ammunition loading time parameter as a copy of the provided original.
   DtAmmoLoadTime(const DtAmmoLoadTime& orig, DtReaderWriterRegistry* const parentRegistry = NULL);
 
   //! \brief Assignment operator
   //! \param orig The source object to copy from
   //! \return Reference to this object after assignment
   //!
   //! Assigns the contents of the provided ammunition loading time parameter to this one.
   DtAmmoLoadTime& operator=(const DtAmmoLoadTime& orig);
 
   //! \brief Creates a clone of this object
   //! \param parentRegistry Parent registry for reader/writer functionality (optional)
   //! \return Pointer to a new object that is a clone of this one
   //!
   //! Creates a new ammunition loading time parameter as a deep copy of this one.
   virtual DtAmmoLoadTime* clone(DtReaderWriterRegistry* parentRegistry = NULL) const;
 
   //! \brief Sets the ammunition name
   //! \param name The name of the ammunition type
   //!
   //! Sets the name that identifies this ammunition type.
   virtual void setAmmoType(const DtEntityType& name);
 
   //! \brief Gets the ammunition name
   //! \return Reference to the ammunition name string
   //!
   //! Gets the name that identifies this ammunition type.
   virtual const DtEntityType& ammoType() const;
 
   //! \brief Sets the ammunition loading time
   //! \param time The loading time in seconds
   //!
   //! Sets the time required to load this ammunition type into a weapon.
   virtual void setLoadTime(double time);
 
   //! \brief Gets the ammunition loading time
   //! \return The loading time in seconds
   //!
   //! Gets the time required to load this ammunition type into a weapon.
   virtual double loadTime() const;
 
   /*virtual char* encode(char*) const;
   virtual const char* decode(const char*);
   virtual int getSize() const;*/
 
   //! \brief Gets the reader/writer type identifier
   //! \return String identifying this reader/writer type
   //!
   //! Returns the type identifier for this reader/writer class.
   virtual const char* readerWriterType() const override;
 
   //! \brief Gets the XML type identifier
   //! \return String identifying this type in XML archives
   //!
   //! Returns the type identifier used when archiving to an XML stream.
   static const char* theXmlType();
 
   //! \brief Gets the XML type identifier for this instance
   //! \return String identifying this type in XML archives
   //!
   //! Returns the type identifier used when archiving this instance to an XML stream.
   virtual const char* xmlType() const override { return theXmlType(); }
 
protected:
   //! \brief The ammunition type name
   //!
   //! Stores the name that identifies this ammunition type.
   DtRwEntityType myAmmoType;
 
   //! \brief The ammunition loading time in seconds
   //!
   //! Stores the time required to load this ammunition type into a weapon.
   DtRwReal myLoadTime;
};
 
//! \brief List of ammunition loading time parameters
//!
//! A templated list of ammunition loading time parameters for managing
//! multiple ammunition types and their loading times for a weapon system.
using DtAmmoLoadTimeList = DtRwTemplatedListPtr<DtAmmoLoadTime, true>;
} // namespace makVre
 
/*namespace DtBufferSerialize
{
   //! \return The number of bytes required to encode the specified spawn data.
   //! \note Passing in a null set data request pointer is valid.
   VREVRFOBJPARAM_DLL int getSize(const makVre::DtAmmoLoadTime&  info);
 
   //! Encodes the specified spawn data into the specified character array.
   //! \return The pointer for buffer following the serialization.
   //! This value may be passed into the next call to encode().
   //! \note Passing in a null set data request pointer is valid.
   VREVRFOBJPARAM_DLL char* encode(const makVre::DtAmmoLoadTime& info, char* buffer);
 
   //! Decodes the buffer into the spawn data.
   //! \return The pointer to buffer after the decode.  This is appropriate to
   //! pass into the next call of decode().
   VREVRFOBJPARAM_DLL const char* decode(makVre::DtAmmoLoadTime& info, const char* buffer);
}*/