WsfWeaponEffects.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 WSFWEAPONEFFECTS_HPP
#define WSFWEAPONEFFECTS_HPP
 
#include "wsf_mil_export.h"
 
#include <vector>
 
class UtInput;
class UtScript;
#include "WsfCategoryList.hpp"
#include "WsfObject.hpp"
class WsfPlatform;
#include "script/WsfScriptContext.hpp"
class WsfWeapon;
class WsfWeaponEngagement;
 
namespace WsfPk
{
class Table;
}

 
class WSF_MIL_EXPORT WsfWeaponEffects : public WsfObject
{
public:
   static WsfStringId GetWeaponEffectsType(WsfPlatform& aPlatform);
 
   static const char* cTYPE_KIND;
   static const double cUNHARMED;

   static const double cMORTALLY_WOUNDED;

   enum Result
   {
      cINVALID, 
      cMISSED,  
      cDAMAGED, 
      cKILLED   
   };
 
   WsfWeaponEffects(WsfScenario& aScenario);
   ~WsfWeaponEffects() override;

   WsfWeaponEffects* Clone() const override = 0;
 
   virtual bool PreInitialize();
   bool         ProcessInput(UtInput& aInput) override;
   virtual bool Initialize(double aSimTime, const WsfWeaponEngagement* aEngagementPtr);
 
   UtScriptContext* GetScriptAccessibleContext() const override { return &mContextPtr->GetContext(); }


   virtual void ProcessEffectExplicit(double aSimTime);
   virtual void ProcessEffectImplicit(double aSimTime);
   virtual void Terminate(double aSimTime);

   void Defeat() { mDefeated = true; }

   bool GetIncidentalDamageAllowed() const { return mIncidentalDamageAllowed; }
 
   void SetIncidentalDamageAllowed(bool aIncidentalDamageAllowed)
   {
      mIncidentalDamageAllowed = aIncidentalDamageAllowed;
   }

   bool GetParentDamageAllowed() const { return mParentDamageAllowed; }
 
   void SetParentDamageAllowed(bool aParentDamageAllowed) { mParentDamageAllowed = aParentDamageAllowed; }
 
   // Deprecated form (use GetIncidentalDamageAllowed);
   // bool AllowIncidentalDamage() const                   { return mIncidentalDamageAllowed; }

   Result GetTargetResult() const { return mTargetResult; }

   Result GetIncidentalResult() const { return mIncidentalResult; }

   Result GetTotalResult() const { return (mTargetResult > mIncidentalResult) ? mTargetResult : mIncidentalResult; }

   static std::string GetResultString(WsfWeaponEffects::Result aResult);

   bool UseLaunchPk() const { return mUseLaunchPk; }

   bool UseInterceptPk() const { return !mUseLaunchPk; }

   double GetPkDegrade() const { return mPkDegrade; }

   double GetPkConstraint() const { return mPkDegrade * ((mUseLaunchPk) ? mLaunchPk : mInterceptPk); }

   void SetInvincibleIndex(unsigned int aPlatformID) { mInvincibleIndex = aPlatformID; }

   unsigned int GetInvincibleIndex() const { return mInvincibleIndex; }

   void SetDamageRadius(double aDamageRadius) { mDamageRadius = aDamageRadius; }

   double GetDamageRadius() const { return mDamageRadius; }

   double GetLaunchPk() const { return mLaunchPk; }

   double GetInterceptPk() const { return mInterceptPk; }

   bool DrawEndgamePk() { return mDrawEndgamePk; }

   virtual double GetCEP() const { return mCEP; }

   void SetCEP(double aValue) { mCEP = aValue; }

   void SetPkDegrade(double aPkDegrade) { mPkDegrade = aPkDegrade; }

   virtual double GetPkDrawn() const { return mPkDrawn; }

   bool DebugEnabled() const { return mDebugEnabled; }

   void SetDebugEnabled(bool aDebugEnabled) { mDebugEnabled = aDebugEnabled; }

   unsigned int KilledPlatformCount() const { return static_cast<unsigned int>(mKilledPlatformIndices.size()); }

   bool IsKilledPlatform(size_t aPlatformIndex) const;
 
   WsfPk::Table* GetPkTable() { return mPkTablePtr; }
 
   WsfScenario& GetScenario() { return *mScenarioPtr; }
 
protected:
   WsfWeaponEffects(const WsfWeaponEffects& aSrc);
   WsfWeaponEffects& operator=(const WsfWeaponEffects& aRhs);
 
   virtual void ApplyEffectIncrement(double aSimTime, WsfPlatform* aOtherPlatformPtr, double aDamageAmount);
   virtual void ApplyEffectTo(double aSimTime, WsfPlatform* aOtherPlatformPtr);
   virtual void ApplyDamageResultToOtherPlatform(double aSimTime, WsfPlatform* aOtherPlatformPtr, double aDamage, Result aResult);
 
   virtual void CalcLaunchPk(double aSimTime);
   virtual void CalcPkDegradation(double aSimTime, WsfPlatform* aTargetPtr);
   virtual void CalcInterceptPk(double aSimTime, WsfPlatform* aTargetPtr);
   virtual void CalcPkParameters(WsfPlatform* aTargetPtr,
                                 double&      aAzimuth,
                                 double&      aElevation,
                                 double&      aMissileSpeed,
                                 double&      aTargetSpeed);
 
   bool IsIntendedTargetValid();
   void AddToKilledPlatforms(unsigned int aKilledIndex);
 
   double       DrawUniformPk();
   virtual bool IsVulnerable(WsfPlatform* aOtherPlatformPtr);
   void         ProcessEffectCommon(double aSimTime, WsfPlatform* aRefPlatformPtr);

   bool Defeated() const { return mDefeated; }

   const WsfWeaponEngagement* GetEngagement() const { return mEngagementPtr; }

   void SetUseLaunchPk() { mUseLaunchPk = true; }

   void SetUseInterceptPk() { mUseLaunchPk = false; }

   void SetLaunchPk(double aValue) { mLaunchPk = aValue; }

   void SetInterceptPk(double aValue) { mInterceptPk = aValue; }

   void SetPkDrawn(double aValue) { mPkDrawn = aValue; }
 
   void SetIncidentalResult(const WsfWeaponEffects::Result& aResult);
   void SetTargetResult(const WsfWeaponEffects::Result& aResult);
   void SetResult(const WsfWeaponEffects::Result& aResult, bool aIsIntended);

   size_t KilledPlatform(size_t aIndex) { return mKilledPlatformIndices[aIndex]; }
 
   const WsfWeaponEngagement* GetEngagementPtr() const { return mEngagementPtr; }
 
   WsfSimulation* GetSimulation() const;
 
   WsfScriptContext* GetScriptContext() const { return mContextPtr; }
 
private:
   WsfScriptContext* mContextPtr;
 
   unsigned int    mInvincibleIndex;
   WsfCategoryList mInvincibleCats;
 
   union
   {
      struct
      {
         bool mDebugEnabled : 1;
         bool mDefeated : 1;
         bool mIncidentalDamageAllowed : 1;
         bool mParentDamageAllowed : 1;
         bool mUseLaunchPk : 1; // if false, use intercept Pk
         bool mRemoveWeaponPlatform : 1;
         bool mDrawEndgamePk : 1; // Force a pk draw for an external platform
      };
      unsigned short mFlags;
   };
 
   double                     mLaunchPk;
   double                     mInterceptPk;
   double                     mPkDegrade;
   double                     mPkDrawn;
   double                     mCEP;
   double                     mDamageRadius;
   WsfScenario*               mScenarioPtr;
   const WsfWeaponEngagement* mEngagementPtr;
   std::vector<size_t>        mKilledPlatformIndices;
   Result                     mTargetResult;
   Result                     mIncidentalResult;
 
   WsfPk::Table* mPkTablePtr;
   WsfStringId   mPkTableNameId;
 
   UtScript* mOnTargetDamagedPtr;
   UtScript* mOnTargetKilledPtr;
 
   UtScriptData* mDamageVarPtr;
};
 
#endif