WsfWeapon.hpp

Go to the documentation of this file.

// ****************************************************************************
// CUI
//
// The Advanced Framework for Simulation, Integration, and Modeling (AFSIM)
//
// Copyright 2003-2015 The Boeing Company. All rights reserved.
//
// The use, dissemination or disclosure of data in this file is subject to
// limitation or restriction. See accompanying README and LICENSE for details.
// ****************************************************************************
 
#ifndef WSFWEAPON_HPP
#define WSFWEAPON_HPP
 
#include <list>
#include <map>
#include <vector>
 
class UtInput;
#include "WsfArticulatedPart.hpp"
#include "WsfComponentList.hpp"
class WsfEM_Rcvr;
class WsfEM_Xmtr;
#include "wsf_mil_export.h"
 
#include "WsfEvent.hpp"
#include "WsfMilComponentRoles.hpp"
class WsfLaunchComputer;
#include "WsfMode.hpp"
#include "WsfModeList.hpp"
#include "WsfRandomVariable.hpp"
#include "WsfStringId.hpp"
#include "WsfTrack.hpp"
#include "WsfTrackId.hpp"
class WsfWeapon;
#include "WsfWeaponComponent.hpp"
class WsfWeaponEngagement;

class WSF_MIL_EXPORT WsfWeapon : public WsfArticulatedPart
{
public:
   static const double cUNDEFINED_DOUBLE;
 
   enum WeaponState
   {
      cWEAPON_STATE_UNALLOCATED,
      cWEAPON_STATE_ALLOCATED,
      cWEAPON_STATE_DEALLOCATE,
      cWEAPON_STATE_NACK,
      cWEAPON_STATE_READY
   };

   class WSF_MIL_EXPORT WsfWeaponMode : public WsfMode
   {
   public:
      WsfWeaponMode(const WsfScenario& aScenario);
      WsfWeaponMode(const WsfWeaponMode& aSrc);
      ~WsfWeaponMode() override = default;
      WsfWeaponMode& operator=(const WsfWeaponMode&) = delete;

      WsfPlatform* GetPlatform() const { return mPlatformPtr; }

      WsfWeapon* GetWeapon() const { return mWeaponPtr; }

      WsfMode* Clone() const override = 0;
 
      virtual bool Initialize(double aSimTime, WsfWeapon* aWeaponPtr);
 
      bool ProcessInput(UtInput& aInput) override;
 
      void Deselect(double aSimTime) override = 0;
      void Select(double aSimTime) override   = 0;
 
      const WsfScenario& GetScenario() const { return mScenario; }
 
   protected:
      const WsfScenario& mScenario;
      WsfPlatform* mPlatformPtr;
      WsfWeapon* mWeaponPtr;
   };

   static double TimeWeaponLastFiredFor(const WsfPlatform& aPlatform,
                                        const WsfTrackId&  aTrackId,
                                        WsfStringId        aWeaponName = WsfStringId());
 
   static double TimeWeaponLastTerminatedFor(const WsfPlatform& aPlatform,
                                             const WsfTrackId&  aTrackId,
                                             WsfStringId        aWeaponName = WsfStringId());
 
   static int WeaponsPendingFor(const WsfPlatform& aPlatform,
                                const WsfTrackId&  aTrackId,
                                WsfStringId        aWeaponName = WsfStringId());
 
   static int WeaponsActiveFor(const WsfPlatform& aPlatform,
                               const WsfTrackId&  aTrackId,
                               WsfStringId        aWeaponName = WsfStringId());
 
   static int RoundsCompleteFor(const WsfPlatform& aPlatform,
                                const WsfTrackId&  aTrackId,
                                WsfStringId        aWeaponName = WsfStringId());
 
   static int WeaponsActiveAndPendingFor(const WsfPlatform& aPlatform,
                                         const WsfTrackId&  aTrackId,
                                         WsfStringId        aWeaponName = WsfStringId());
 
   static int RoundsFiredAt(const WsfPlatform& aPlatform,
                            const WsfTrackId&  aTrackId,
                            WsfStringId        aWeaponName = WsfStringId());
 
   static int SalvosFiredAt(const WsfPlatform& aPlatform,
                            const WsfTrackId&  aTrackId,
                            WsfStringId        aWeaponName = WsfStringId());
 
   static std::vector<size_t> ActiveWeaponPlatformsFor(const WsfPlatform& aPlatform,
                                                       const WsfTrackId&  aTrackId,
                                                       WsfStringId        aWeaponName = WsfStringId());
 
   static void DetermineFirepowerStatus(WsfPlatform& aPlatform);
 
   WsfWeapon(const WsfScenario& aScenario);
   ~WsfWeapon() override;


   using ComponentList = WsfComponentListT<WsfWeaponComponent>;
   ComponentList&       GetComponents() { return mComponents; }
   const ComponentList& GetComponents() const { return mComponents; }


   WsfComponent* CloneComponent() const override { return Clone(); }
   const int*    GetComponentRoles() const override;
   void*         QueryInterface(int aRole) override;
   int           GetComponentInitializationOrder() const override { return cWSF_INITIALIZE_ORDER_WEAPON; }


   const char* GetScriptClassName() const override;
   WsfWeapon* Clone() const override = 0;
   bool       PreInitialize(double aSimTime) override;
   bool       Initialize(double aSimTime) override;
   bool       Initialize2(double aSimTime) override;
   void       PreInput() override;
   bool       ProcessInput(UtInput& aInput) override;
   void       Update(double aSimTime) override;


   void TurnOff(double aSimTime) override;
   void TurnOn(double aSimTime) override;
   void SetNonOperational(double aSimTime) override;
   void SetOperational(double aSimTime) override;
   void PartBroken(double aSimTime) override;
   void Restore(double aSimTime) override;

   double GetUpdateInterval() const override { return mUpdateInterval; }


   virtual size_t      GetEM_RcvrCount() const;
   virtual WsfEM_Rcvr& GetEM_Rcvr(size_t aIndex);
 
   virtual size_t      GetEM_XmtrCount() const;
   virtual WsfEM_Xmtr& GetEM_Xmtr(size_t aIndex);
   virtual size_t      GetEM_XmtrCount(size_t aModeIndex) const;
   virtual WsfEM_Xmtr& GetEM_Xmtr(size_t aModeIndex, size_t aIndex);
   virtual WsfEM_Xmtr& GetEM_Xmtr(size_t aModeIndex, size_t aBeamIndex, size_t aIndex);


   virtual WsfStringId    GetCurrentModeName() const;
   virtual WsfWeaponMode* GetCurrentMode();
   virtual size_t         GetModeCount();
   virtual WsfWeaponMode* GetModeEntry(size_t aModeIndex);
   virtual size_t         GetModeIndex(WsfStringId aModeNameId);
   virtual WsfStringId    GetModeName(size_t aModeIndex);
   virtual void           DeselectMode(double aSimTime, WsfStringId aModeNameId);
   virtual void           SelectMode(double aSimTime, WsfStringId aModeNameId);



   WsfLaunchComputer* GetLaunchComputer() const { return mLaunchComputerPtr; }
 
   void SetLaunchComputer(WsfLaunchComputer* aLaunchComputerPtr);



   WsfStringId GetWeaponEffectsType() const { return mWeaponEffectsType.GetConstReference(); }

   void SetWeaponEffectsType(WsfStringId aWeaponEffect) { mWeaponEffectsType = aWeaponEffect; }

   class FireTarget
   {
   public:
      FireTarget()
         : mTrackPtr(nullptr)
      {
      }
      FireTarget(const WsfTrack* aTrackPtr)
         : mTrackPtr(aTrackPtr)
      {
         if (mTrackPtr != nullptr)
         {
            mTrackId = mTrackPtr->GetTrackId();
         }
      }

      const WsfTrack* mTrackPtr;

      std::string mTargetName;
 
      WsfTrackId mTrackId; // For convenience only...

      std::string mTargetOffset;
   };

   class FireOptions
   {
   public:
      FireOptions()
         : mWeaponId(0)
      {
      }
 
      FireOptions(int aWeaponId)
         : mWeaponId(aWeaponId)
      {
      }

      int mWeaponId;

      std::string mWeaponPlatformName;

      WsfStringId mWeaponComponentName;
   };

   class SalvoOptions : public FireOptions
   {
   public:
      SalvoOptions()
         : SalvoOptions(1)
      {
      }
 
      SalvoOptions(int aQuantity, double aSalvoInterval = -1.0, int aWeaponId = 0)
         : FireOptions(aWeaponId)
         , mQuantity(aQuantity)
         , mSalvoInterval(aSalvoInterval)
      {
      }
 
      int    mQuantity;      
      double mSalvoInterval; 
   };

   class FireResult
   {
   public:
      FireResult()
         : mSuccess(false)
         , mEngagementPtr(nullptr)
      {
      }
 
      FireResult(bool aResult)
         : mSuccess(aResult)
         , mEngagementPtr(nullptr)
      {
      }
 
      operator bool() const { return mSuccess; }

      bool mSuccess;
      WsfWeaponEngagement* mEngagementPtr;
   };


   virtual void CueToTarget(double aSimTime, const WsfTrack* aTrackPtr);
 
   virtual FireResult Fire(double aSimTime, const FireTarget& aTarget, const FireOptions& aSettings);
 
   virtual bool FireSalvo(double aSimTime, const FireTarget& aTarget, const SalvoOptions& aSettings);
 
   virtual void ContinueSalvo(double aSimTime, unsigned int aRequestId);
 
   virtual void AbortSalvo(double aSimTime, const WsfTrackId& aTrackId);
 
   virtual void CeaseFire(double aSimTime);

   virtual unsigned int GetActiveRequestCount() const { return static_cast<unsigned int>(mSalvoRequestList.size()); }

   virtual unsigned int GetMaximumRequestCount() const { return mMaximumRequestCount; }



   double GetTimeLastFired() const { return mTimeLastFired; }

   virtual double GetFiringDelay() { return mFiringDelay.Draw(); }

   void SetFiringDelay(const WsfRandomVariable& aFiringDelay) { mFiringDelay = aFiringDelay; }

   virtual double GetSalvoInterval() { return mSalvoInterval.Draw(); }

   double GetFiringInterval() const { return mFiringInterval; }

   void SetFiringInterval(double aFiringInterval) { mFiringInterval = aFiringInterval; }



   WsfStringId GetLaunchedPlatformType() const { return mLaunchedPlatformType; }

   void SetLaunchedPlatformType(WsfStringId aLaunchedPlatformType) { mLaunchedPlatformType = aLaunchedPlatformType; }



   double         GetInitialStateQuantityRemaining() const { return mInitialStateQuantityRemaining; }
   virtual double GetQuantityRemaining() const;
   virtual double GetQuantityCommitted() const;
   virtual double GetMaximumQuantity() const;
   virtual double GetTotalQuantityUsed() const;
   virtual void   SetQuantityRemaining(double aQuantity);
   void           ChangeQuantity(double aDeltaQuantity);



   bool IsReloading() const { return mIsReloading; }

   bool InhibitWhileReloading() const { return mInhibitWhileReloading; }
 
   virtual void CompleteReloading(double aSimTime, double aQuantity);

   double GetReloadInventory() const { return mReloadInventory; }

   double GetReloadThreshold() const { return mReloadThreshold; }

   double GetReloadIncrement() const { return mReloadIncrement; }


   WsfTrack* CreateTargetTrack(double aSimTime, const WsfTrack* aTrackPtr);
 
   bool GetTargetLocationWCS(double aSimTime, const WsfTrack* aTrackPtr, double aTargetLocWCS[3]);


   virtual void   SetTargetIndex(int aId, size_t aTargetIndex) {}
   virtual size_t GetTargetIndex(int aId) const { return 0; }
 
   virtual void SetTargetedLocationWCS(int aId, const double aTargetedLocationWCS[3]) {}
   virtual void GetTargetedLocationWCS(int aId, double aTargetedLocationWCS[3]) const {}
 
   virtual bool TargetedLocationValid(int aId) const { return false; }



   virtual bool WithinFieldOfView(double aSimTime, WsfPlatform* aPlatformPtr);
   virtual bool WithinFieldOfView(double aSimTime, WsfTrack* aTrackPtr);


 
   virtual bool StartJamming(double      aSimTime,
                             double      aFrequency,
                             double      aBandwidth,
                             size_t      aBeamNumber,
                             WsfStringId aTechniqueId,
                             WsfTrackId  aTrackId,
                             size_t      aTargetIndex)
   {
      return false;
   }
   virtual bool StartJammingTrack(double aSimTime, WsfStringId aTechniqueId, const WsfTrack* aTrackPtr)
   {
      return false;
   }
 
   virtual bool StopJamming(double aSimTime, double aFrequency, double aBandwidth, size_t aBeamNumber, WsfTrackId aTrackId)
   {
      return false;
   }
 
   virtual bool UpdateJamming(double      aSimTime,
                              size_t      aXmtrIndex,
                              double      aFrequency,
                              double      aBandwidth,
                              WsfStringId aTechniqueId,
                              WsfTrackId  aTrackId,
                              size_t      aTargetIndex)
   {
      return false;
   }
 
   virtual size_t GetActiveBeamCount() const { return 0; }
   virtual size_t GetMaximumBeamCount() const { return 0; }
   virtual size_t GetActiveSpotCount(size_t aBeamNumber) const { return 0; }
   virtual size_t GetMaximumSpotCount(size_t aBeamNumber) const { return 0; }


   virtual bool SelectEA_Technique(double      aSimTime,
                                   double      aFrequency,
                                   double      aBandwidth,
                                   size_t      aBeamNumber,
                                   WsfStringId aTechniqueId,
                                   WsfTrackId  aTrackId)
   {
      return false;
   }
 
   virtual bool DeselectEA_Technique(double      aSimTime,
                                     double      aFrequency,
                                     double      aBandwidth,
                                     size_t      aBeamNumber,
                                     WsfStringId aTechniqueId,
                                     WsfTrackId  aTrackId)
   {
      return false;
   }
 
   virtual bool SetEA_DeltaGainTechnique(double      aSimTime,
                                         WsfStringId aTechniqueId,
                                         bool        aOnOff,
                                         WsfStringId aEffectId,
                                         double      aJammingDeltaGain_dB,
                                         WsfStringId aSystemTypeId,
                                         WsfStringId aFunctionTypeId)
   {
      return false;
   }
 
   virtual bool SetEA_DeltaGainTechnique(double      aSimTime,
                                         WsfStringId aTechniqueId,
                                         bool        aOnOff,
                                         WsfStringId aEffectId,
                                         double      aJammingDeltaGain_dB,
                                         WsfStringId aSystemTypeId,
                                         WsfStringId aFunctionTypeId,
                                         double      aFrequency,
                                         double      aBandwidth,
                                         size_t      aBeamNumber,
                                         WsfTrackId  aTrackId)
   {
      return false;
   };


   //{@
   void SetUpdateInterval(double aUpdateInterval) override { mUpdateInterval = aUpdateInterval; }


   double              TimeWeaponLastFiredFor(const WsfTrackId& aTrackId) const;
   double              TimeWeaponLastTerminatedFor(const WsfTrackId& aTrackId) const;
   int                 WeaponsPendingFor(const WsfTrackId& aTrackId) const;
   int                 WeaponsActiveFor(const WsfTrackId& aTrackId) const;
   int                 RoundsCompleteFor(const WsfTrackId& aTrackId) const;
   int                 WeaponsActiveAndPendingFor(const WsfTrackId& aTrackId) const;
   int                 RoundsFiredAt(const WsfTrackId& aTrackId) const;
   int                 SalvosFiredAt(const WsfTrackId& aTrackId) const;
   std::vector<size_t> ActiveWeaponPlatformsFor(const WsfTrackId& aTrackId) const;
 
   virtual void EngagementComplete(double aSimTime, WsfWeaponEngagement* aEngagementPtr);

   void SetIFCEnabled(bool aEnabled) { mIFCEnabled = aEnabled; }

   bool GetIFCEnabled() const { return mIFCEnabled; }


   virtual bool AllocateTheWeapon(double aSimTime, WsfTrack* aTrackPtr, int aStoreId);
 
   void SetState(WeaponState aState);

   WeaponState GetState() const { return mState; }

 
protected:
   WsfWeapon(const WsfWeapon& aSrc);
   WsfWeapon& operator=(const WsfWeapon&) = delete;
 
   bool IsQuantitySpecified() const { return mIsQuantitySpecified; }
 
   virtual void ProcessReloading(double aSimTime);

   void SetIsReloading(bool aValue) { mIsReloading = aValue; }
 
   void SetModeList(WsfModeList* aModeListPtr);
 
   void SetTimeLastFired(double aTimeLastFired);
 
   void SetMaximumRequestCount(unsigned int aMaximumRequestCount) { mMaximumRequestCount = aMaximumRequestCount; }
 
   class WSF_MIL_EXPORT SalvoEvent : public WsfEvent
   {
   public:
      SalvoEvent(double aSimTime, WsfWeapon* aWeaponPtr, unsigned int aRequestId);
      ~SalvoEvent() override = default;
      EventDisposition Execute() override;
 
   private:
      WsfWeapon*   mWeaponPtr;
      size_t       mPlatformIndex;
      unsigned int mRequestId;
   };
 
   class WSF_MIL_EXPORT CompleteReloadEvent : public WsfEvent
   {
   public:
      CompleteReloadEvent(double aCompletionTime, double aReloadedAmount, WsfWeapon* aWeaponPtr);
      ~CompleteReloadEvent() override = default;
      EventDisposition Execute() override;
 
   private:
      WsfWeapon* mWeaponPtr;
      size_t     mPlatformIndex;
      double     mQuantity;
   };
 
   struct SalvoRequest
   {
   public:
      SalvoRequest(unsigned int aRequestId, const FireTarget& aTarget, const SalvoOptions& aSettings);
      virtual ~SalvoRequest();
 
      unsigned int mRequestId;
      FireTarget   mTarget;
      SalvoOptions mSettings;
   };
 
protected:
   WsfModeList* mModeListPtr;
 
   double GetReloadInterval() const { return mReloadTime; }

   struct ActiveWeapon
   {
      ActiveWeapon(size_t weaponPlatIndex, unsigned int serialNum)
         : mPlatformIndex(weaponPlatIndex)
         , mSerialNumber(serialNum)
      {
      }

      size_t mPlatformIndex;
      unsigned int mSerialNumber;
   };

   struct WeaponStatus
   {
   public:
      WeaponStatus()
         : mTimeWeaponLastFired(-1.0)
         , mTimeWeaponLastTerminated(-1.0)
         , mTotalSalvosFired(0)
         , mRoundsCompleted(0)
         , mRoundsPending(0)
         , mRoundsActive(0)
      {
      }

      double mTimeWeaponLastFired;
      double mTimeWeaponLastTerminated;
      int mTotalSalvosFired;
      int mRoundsCompleted;
      int mRoundsPending;
      int mRoundsActive;
      std::list<ActiveWeapon> mActiveWeaponList;
   };
   using WeaponStatusMap          = std::map<WsfTrackId, WeaponStatus>;
   using WeaponStatusMapIter      = WeaponStatusMap::iterator;
   using WeaponStatusMapConstIter = WeaponStatusMap::const_iterator;
   using WeaponStatusVal          = std::pair<WsfTrackId, WeaponStatus>;
   WeaponStatusMap mWeaponStatusMap;
 
   virtual void WeaponFireAborted(double aSimTime, const WsfTrack* aTargetTrackPtr, double aQuantity);
 
private:
   enum AltitudeReference
   {
      cAR_AGL,
      cAR_MSL,
      cAR_RELATIVE
   };
 
   using SalvoRequestList = std::vector<std::unique_ptr<SalvoRequest>>;
 
   ComponentList mComponents;

   WsfVariable<double> mUpdateInterval;

   unsigned int mUpdateEventEpoch;

   bool mUpdateEventActive;

   WsfVariable<WsfStringId> mLaunchedPlatformType;

   WsfVariable<WsfStringId> mWeaponEffectsType;

   WsfVariable<double> mQuantityRemaining;

   bool mIsQuantitySpecified;

   double mInitialStateQuantityRemaining;

   WsfVariable<double> mMaximumQuantity;

   double mTotalQuantityUsed;

   double mQuantityCommitted;

   WsfVariable<double> mReloadThreshold;

   WsfVariable<double> mReloadIncrement;

   WsfVariable<double> mReloadInventory;

   WsfRandomVariable mReloadTime;

   WsfRandomVariable mFiringDelay;

   WsfRandomVariable mSalvoInterval;

   WsfVariable<double> mFiringInterval;

   double mTimeLastFired;

   unsigned int mMaximumRequestCount;

   unsigned int mSalvoRequestId;

   SalvoRequestList mSalvoRequestList;

   WsfVariable<double> mUnknownTargetRange;

   WsfVariable<double> mUnknownTargetAltitude;

   AltitudeReference mUnknownTargetAltitudeRef;

   WeaponState mState;

   bool mAutomaticTargetCueing;

   bool mCueToPredictedIntercept;

   bool mIsReloading;

   bool mInhibitWhileReloading;

   bool mIFCEnabled;
 
   WsfLaunchComputer* mLaunchComputerPtr;

   std::vector<WsfWeaponMode*> mWeaponModeList;
};
 
WSF_DECLARE_COMPONENT_ROLE_TYPE(WsfWeapon, cWSF_COMPONENT_WEAPON)
 
#endif