WsfWeaponEngagement.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 WSFWEAPONENGAGEMENT_HPP
#define WSFWEAPONENGAGEMENT_HPP
 
#include "wsf_mil_export.h"
 
#include <memory>
#include <string>
 
class UtScriptClass;
class UtScriptTypes;
#include "WsfEvent.hpp"
class WsfPlatform;
#include "WsfStringId.hpp"
#include "WsfTrackId.hpp"
class WsfWeapon;
#include "WsfWeaponEffects.hpp"

 
class WSF_MIL_EXPORT WsfWeaponEngagement : public UtScriptAccessible
{
public:
   enum GeometryResult
   {
      cIN_PROGRESS,                    
      cDUD,                            
      cTARGET_IMPACT,                  
      cFAR_AWAY_IN_AIR,                
      cFAR_AWAY_ABOVE_GROUND,          
      cFAR_AWAY_GROUND_IMPACT,         
      cTARGET_PROXIMITY_AIR_BURST,     
      cTARGET_PROXIMITY_ABOVE_GROUND,  
      cTARGET_PROXIMITY_GROUND_IMPACT, 
      cPART_DISABLED_OR_DESTROYED      
   };
 
   static WsfWeaponEngagement* Find(const WsfPlatform& aPlatform);
 
   static bool Assign(WsfPlatform& aPlatform, WsfWeaponEngagement*& aEngagementPtr);
 
   static std::unique_ptr<UtScriptClass> CreateScriptClass(const std::string& aClassName, UtScriptTypes* aScriptTypesPtr);
 
   static bool EnumToString(std::string& aString, GeometryResult aGeometryResult);
 
   static bool StringToEnum(GeometryResult& aGeometryResult, const std::string& aString);
 
   WsfWeaponEngagement() = delete;
 
   WsfWeaponEngagement(double            aStartTime,
                       WsfSimulation*    aSimulationPtr,
                       WsfWeapon*        aWeaponSystemPtr,
                       const WsfTrackId& aTargetTrackId,
                       size_t            aIntendedTargetIndex,
                       WsfStringId       aWeaponEffectsType,
                       WsfStringId       aIntendedTargetOffsetName = WsfStringId());
 
   static void Delete(WsfWeaponEngagement* aEngagementPtr);
 
   const char* GetScriptClassName() const override { return "WsfWeaponEngagement"; }

   virtual bool Initialize(double aSimTime, WsfPlatform* aWeaponPlatformPtr);
 
   bool Initialize(WsfPlatform* aWeaponPlatformPtr);
 
   virtual void Update(double aSimTime);
 
   // NOTE: This is not virtual for a reason. See the implementation file.
   void Terminate(double aSimTime, GeometryResult aGeometryResult = cFAR_AWAY_IN_AIR);

   void Defeat()
   {
      if (mEffectPtr != nullptr)
      {
         mEffectPtr->Defeat();
      }
   }

   void SetExtendedResult(const std::string& aExtendedResult) { mExtendedResult = aExtendedResult; }

   void SetIsExternallyControlled(bool aIsExternallyControlled) { mIsExternallyControlled = aIsExternallyControlled; }

   void SetWeaponEffects(WsfStringId aWeaponEffectsType);
 
   void SetInitialWeaponVelocityWCS(const double aInitialVelWCS[3]);
 
   void SetInitialTargetLocationWCS(const double aInitialLocWCS[3]);




   WsfWeaponEffects* GetWeaponEffects() const { return mEffectPtr; }

   unsigned int GetSerialNumber() const { return mSerialNumber; }

   double GetStartTime() const { return mStartTime; }

   double GetElapsedTime(double aSimTime) const;

   double GetCompletionTime() const { return mCompletionTime; }

   void SetCompletionTime(double aCompletionTime) { mCompletionTime = aCompletionTime; }

   bool IsComplete() const { return mIsComplete; }

   bool IsExternallyControlled() const { return mIsExternallyControlled; }



 
   WsfPlatform* GetFiringPlatform() const;
   void         SetFiringPlatform(WsfPlatform* aPlatform);

   size_t GetFiringPlatformIndex() const { return mFiringPlatformIndex; }
 
   WsfStringId GetFiringPlatformName() const;
 
   const WsfWeapon* GetWeaponSystem() const;

   WsfStringId GetWeaponSystemName() const { return mWeaponSystemName; }

   WsfStringId GetWeaponSystemType() const { return mWeaponSystemType; }
 
   WsfPlatform* GetWeaponPlatform() const;

   size_t GetWeaponPlatformIndex() const { return mWeaponPlatformIndex; }
 
   WsfStringId GetWeaponPlatformName() const;

   const WsfTrackId& GetInitialTargetTrackId() const { return mInitialTargetTrackId; }
 
   const WsfTrackId& GetTargetTrackId() const;
 
   size_t GetTargetPlatformIndex() const;
 
   WsfPlatform* GetTargetPlatform() const;
 
   WsfStringId GetIntendedTargetName() const;
 
   WsfStringId GetIntendedTargetOffsetName() const { return mIntendedTargetOffsetName; }




   GeometryResult GetGeometryResult() const { return mGeometryResult; }

   WsfWeaponEffects::Result GetTargetResult() const { return mEffectPtr->GetTargetResult(); }

   WsfWeaponEffects::Result GetIncidentalResult() const { return mEffectPtr->GetIncidentalResult(); }

   std::string GetExtendedResult() const { return mExtendedResult; }
 
   void GetTargetLocationWCS(WsfPlatform* aTargetPtr, double aTargetLocWCS[3]) const;
   void SetTargetLocationWCS(WsfPlatform* aTargetPtr, const double aTargetLocWCS[3]);
   void GetWeaponLocationWCS(WsfPlatform* aWeaponPtr, double aWeaponLocWCS[3]) const;
   void SetWeaponLocationWCS(WsfPlatform* aWeaponPtr, const double aWeaponLocWCS[3]);
 
   void GetWeaponVelocityWCS(double aWeaponVelWCS[3]) const;
   void SetWeaponVelocityWCS(const double aWeaponVelWCS[3]);
 
   void GetTargetLocationAtLaunchWCS(double aTargetLocWCS[3]) const;
   void GetWeaponLocationAtLaunchWCS(double aWeaponLocWCS[3]) const;
   void GetWeaponVelocityAtLaunchWCS(double aWeaponVelWCS[3]) const;
 
   void GetWeaponLocationECS(double aWeaponLocECS[3]) const;
   void GetWeaponVelocityECS(double aWeaponVelECS[3]) const;
 
   double GetMissDistance(WsfPlatform* aTargetPtr) const;

   void SetMissDistance(double aMissDistance) { mMissDistance = aMissDistance; }
 
   WsfSimulation* GetSimulation() const { return mSimulationPtr; }
 
   static void CopySerialNumber(const WsfWeaponEngagement* aRealEngPtr, WsfWeaponEngagement* aTempEngPtr);

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

   bool GetIFCEnabled() const { return mIFCEnabled; }
 
protected:
   void UpdateIntendedTarget() const;
 
   WsfWeaponEngagement(const WsfWeaponEngagement& aSrc) = delete;
   WsfWeaponEngagement& operator=(const WsfWeaponEngagement& aRhs) = delete;
 
   // NOTE: See the code as to why this is protected.
   virtual ~WsfWeaponEngagement();
 
private:
   class TerminateEvent;
   friend class TerminateEvent;
 
   class TerminateEvent : public WsfEvent
   {
   public:
      TerminateEvent(double aSimTime, WsfWeaponEngagement* aEngagementPtr);
      EventDisposition Execute() override;
 
      WsfWeaponEngagement* mEngagementPtr;
   };
 
   virtual void PrivateTerminate(double aSimTime);
 
   WsfSimulation*      mSimulationPtr;
   double              mStartTime;
   double              mCompletionTime;
   unsigned int        mSerialNumber;
   size_t              mFiringPlatformIndex;
   size_t              mWeaponPlatformIndex; // Cannot immediately determine mWeaponPlatformIndex, set later
   mutable size_t      mIntendedTargetIndex;
   mutable WsfStringId mIntendedTargetName; // Primarily used for output if the target is destroyed
   WsfStringId         mIntendedTargetOffsetName;
   WsfStringId         mWeaponSystemName;
   WsfStringId         mWeaponSystemType;

   WsfTrackId mInitialTargetTrackId;

   mutable WsfTrackId mTargetTrackId;
 
   WsfWeaponEffects* mEffectPtr;

   GeometryResult mGeometryResult;

   std::string mExtendedResult;

   double mWeaponLocAtLaunchWCS[3];
   double mWeaponVelAtLaunchWCS[3];

   double mWeaponVelWCS[3];

   double mTargetLocAtLaunchWCS[3];

   double mComputedWeaponLocWCS[3];
   size_t mComputedWeaponIndex;

   double mComputedTargetLocWCS[3];
   size_t mComputedTargetIndex;

   double mMissDistance;

   bool mIsExternallyControlled;

   bool mIsInitialized;

   bool mIsComplete;

   bool mTerminatePending;

   bool mDestroyPending;

   bool mInitialWeaponVelocitySet;

   bool mInitialTargetLocationSet;

   bool mIFCEnabled;
};
 
#endif