WsfSA_Assess.hpp

Go to the documentation of this file.

// ****************************************************************************
// CUI//REL TO USA ONLY
//
// The Advanced Framework for Simulation, Integration, and Modeling (AFSIM)
//
// Copyright 2020 Infoscitex, a DCS 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 WSF_SA_ASSESS_HPP
#define WSF_SA_ASSESS_HPP
 
#include "wsf_air_combat_export.h"
 
#include "UtMath.hpp"
#include "WsfSA_Module.hpp"
#include "WsfSA_Perceive.hpp"
 
class WsfAirMover;
class WsfFuel;
class WsfSA_EntityPerception;
class WsfSA_Group;
class WsfSA_Processor;
class WsfSA_PerceivedItem;

class WSF_AIR_COMBAT_EXPORT WsfSA_Assess : WsfSA_Module
{
public:
   friend class WsfSA_Processor;
 
   WsfSA_Assess(WsfSA_Processor* aSA_ProcPtr, WsfSA_Processor::PerceiveData* aDataPtr);
   WsfSA_Assess& operator=(const WsfSA_Assess&) = delete;
   ~WsfSA_Assess();
 
   struct AssessEngagementData
   {
      size_t      targetIndex{0};
      std::string targetName{};
      std::string targetType{};
      float       angleOff_deg{0.0f};
      float       aspectAngle_deg{0.0f};
      float       currentRange_nm{0.0f};
      float       currentDeltaAlt_ft{0.0f};
      float       trackQuality{0.0f};
      std::string targetCID{};
      float       threatLevel{0.0f};
      float       targetValue{0.0f};
      float       detectionRange_nm{0.0f};
      float       wezDesiredRange_nm{0.0f};
      float       wezMinimum_nm{0.0f};
      float       wezMaximum_nm{0.0f};
      float       wezNoEscape_nm{0.0f};
      float       risk{0.0f};
      float       defensiveness{0.0f};
      float       urgency{0.0f};
      bool        tgtTracked{false};
      bool        acceptableWez{false};
   };

   bool ProcessInput(UtInput& aInput);

   void Initialize(double aSimTime);

   double TryUpdateEngagements(double aSimTime);

   double TryUpdatePrioritizedItemData(double aSimTime);

   double TryUpdatePrioritizedItemCalculation(double aSimTime);

   void UpdateEngagements(double aSimTime);

   void UpdatePrioritizedItemData(double aSimTime);

   void UpdatePrioritizedItemCalculation(double aSimTime);

   void UpdateEngagementsData(double aSimTime);

   void UpdatePrioritizedThreatsAndTargetsData(double aSimTime);

   void AssessBogiesBandits(double aSimTime);

   void CalculatePrioritizedThreats(double aSimTime);

   void CalculatePrioritizedTargets(double aSimTime);

   void UpdateWeaponSupport(double aSimTime);

   unsigned int MaxPrioritizedThreats() { return mMaxPrioritizedThreats; }

   void SetMaxPrioritizedThreats(unsigned int aMax) { mMaxPrioritizedThreats = aMax; }

   void ResetMaxPrioritizedThreats() { mMaxPrioritizedThreats = mMaxPrioritizedThreatsInitial; }

   unsigned int MaxPrioritizedTargets() { return mMaxPrioritizedTargets; }

   void SetMaxPrioritizedTargets(unsigned int aMax) { mMaxPrioritizedTargets = aMax; }

   void ResetMaxPrioritizedTargets() { mMaxPrioritizedTargets = mMaxPrioritizedTargetsInitial; }
 
   // .......................................................................................................................
 
   // These functions support "angles" related calculations (angle off and aspect angle)
   // These functions support "angle off" related calculations

   static double AngleOffTarget2D(const WsfPlatform& aPlatform, const WsfPlatform& aTargetPlatform);

   double AngleOffTarget2D(const WsfPlatform& aTargetPlatform) const;

   static double AngleOffTarget3D(const WsfPlatform& aPlatform, const WsfPlatform& aTargetPlatform);

   double AngleOffTarget3D(const WsfPlatform& aTargetPlatform) const;
 
   // These functions support "aspect angle" related calculations

   static double AspectAngleForTarget2D(const WsfPlatform& aPlatform, const WsfPlatform& aTargetPlatform);

   double AspectAngleForTarget2D(const WsfPlatform& aTargetPlatform) const;

   static double AspectAngleForTarget3D(const WsfPlatform& aPlatform, const WsfPlatform& aTargetPlatform);

   double AspectAngleForTarget3D(const WsfPlatform& aTargetPlatform) const;

   static double OffBoresightAngleForTarget(const WsfPlatform& aPlatform, const WsfPlatform& aTargetPlatform);

   double OffBoresightAngleForTarget(const WsfPlatform& aTargetPlatform) const;

   double OffBoresightAngleForTarget(const double aLocationWCS[3]) const;
 
   // .......................................................................................................................
 
   // These functions support "angles" related calculations (angle off and aspect angle)
   // These functions support "detection" related calculations

   double ExpectedDetectionRangeAgainstTarget(const WsfPlatform& aTargetPlatform) const;

   double ExpectedDetectionRangeAgainstTarget(size_t aIndex) const;

   double ExpectedDetectionRangeByTarget(const WsfPlatform& aTargetPlatform) const;

   double ExpectedDetectionRangeByTarget(size_t aIndex) const;

   double ExpectedDetectionRange(const WsfPlatform& aSourePlatform, const WsfPlatform& aTargetPlatform) const;

   double ExpectedNormalizedDetectionRangeAgainstTarget(const WsfPlatform& aTargetPlatform) const;

   double ExpectedNormalizedDetectionRangeAgainstTarget(size_t aIndex) const;
 
   // .......................................................................................................................
 
   // These functions support "WEZ" related calculations

   double ExpectedNormalizedWezRangeAgainstTarget(const WsfPlatform& aTargetPlatform) const;

   double ExpectedNormalizedWezRangeAgainstTarget(size_t aIndex) const;

   double ExpectedWezRangeAgainstTarget(const WsfPlatform& aTargetPlatform) const;

   double ExpectedWezRangeAgainstTarget(size_t aIndex) const;

   double ExpectedMinimumEngagementRangeAgainstTarget(const WsfPlatform& aTargetPlatform) const;

   double ExpectedMinimumEngagementRangeAgainstTarget(size_t aIndex) const;

   double ExpectedMaximumEngagementRangeAgainstTarget(const WsfPlatform& aTargetPlatform) const;

   double ExpectedMaximumEngagementRangeAgainstTarget(size_t aIndex) const;

   double ExpectedNoEscapeRangeAgainstTarget(const WsfPlatform& aTargetPlatform) const;

   double ExpectedNoEscapeRangeAgainstTarget(size_t aIndex) const;

   double ExpectedWezRangeByTarget(const WsfPlatform& aTargetPlatform) const;

   double ExpectedWezRangeByTarget(size_t aIndex) const;
 
   // .......................................................................................................................
 
   // These functions support range-related calculations

   double CalcSlantRange(const WsfPlatform& aSourcePlatform, const WsfPlatform& aTargetPlatform) const;

   double CalcSlantRange(const WsfPlatform& aTargetPlatform) const;
 
   // .......................................................................................................................
 
   // These functions support altitude-related calculations

   double CalcDeltaAltitude(const WsfPlatform& aSourcePlatform, const WsfPlatform& aTargetPlatform) const;

   double CalcDeltaAltitude(const WsfPlatform& aTargetPlatform) const;
 
   // .......................................................................................................................
 
   // These functions support "weapons" related calculations

   bool WeaponBayDoorsOpen() const { return false; }

   bool GetWeaponBayOpen() { return mWeaponBayOpen; }

   void SetWeaponBayOpen(bool aWeaponBayOpen) { mWeaponBayOpen = aWeaponBayOpen; }

   std::string GetSelectedWeapon() { return mSelectedWeapon; }

   void SetSelectedWeapon(const std::string& aSelectedWeapon) { mSelectedWeapon = aSelectedWeapon; }
 
   // .......................................................................................................................
 
   // These functions support "speed" related calculations

   double GetCornerSpeed_KCAS() const { return 0; }
 
   // .......................................................................................................................
 
   // These functions support "threat" related calculations

   std::vector<WsfSA_PerceivedItem*> PerceivedThreatItems(double aSimTime);

   std::vector<size_t> PrioritizedThreatIds() const { return mPrioritizedThreatIds; }

   std::vector<std::string> PrioritizedThreatNames() const { return mPrioritizedThreatNames; }

   const std::list<UtWeakReference<WsfSA_PerceivedItem>>& GetPrioritizedThreatItems() const
   {
      return mPrioritizedThreatItems;
   }

   std::list<UtWeakReference<WsfSA_PerceivedItem>>& GetPrioritizedThreatItems() { return mPrioritizedThreatItems; }

   const std::list<UtWeakReference<WsfSA_EntityPerception>>& GetPrioritizedThreatEntities() const
   {
      return mPrioritizedThreatEntities;
   }

   std::list<UtWeakReference<WsfSA_EntityPerception>>& GetPrioritizedThreatEntities()
   {
      return mPrioritizedThreatEntities;
   }

   const std::list<UtWeakReference<WsfSA_EntityPerception>>& GetPrioritizedAircraftThreatEntities() const
   {
      return mPrioritizedAircraftThreatEntities;
   }

   std::list<UtWeakReference<WsfSA_EntityPerception>>& GetPrioritizedAircraftThreatEntities()
   {
      return mPrioritizedAircraftThreatEntities;
   }

   const std::list<UtWeakReference<WsfSA_EntityPerception>>& GetPrioritizedMissileThreatEntities() const
   {
      return mPrioritizedMissileThreatEntities;
   }

   std::list<UtWeakReference<WsfSA_EntityPerception>>& GetPrioritizedMissileThreatEntities()
   {
      return mPrioritizedMissileThreatEntities;
   }

   const std::list<UtWeakReference<WsfSA_Group>>& GetPrioritizedThreatGroups() const
   {
      return mPrioritizedThreatGroups;
   }

   std::list<UtWeakReference<WsfSA_Group>>& GetPrioritizedThreatGroups() { return mPrioritizedThreatGroups; }

   WsfSA_PerceivedItem* HighestThreat(double aSimTime);

   WsfSA_EntityPerception* HighestThreatEntity(double aSimTime);

   WsfSA_EntityPerception* HighestThreatAircraft(double aSimTime);

   WsfSA_EntityPerception* HighestThreatMissile(double aSimTime);

   WsfSA_Group* HighestThreatGroup(double aSimTime);
 
   // .......................................................................................................................
 
   // These functions support "target" related calculations

   std::vector<size_t> PrioritizedTargetIds() const { return mPrioritizedTargetIds; }

   std::vector<std::string> PrioritizedTargetNames() const { return mPrioritizedTargetNames; }

   const std::list<UtWeakReference<WsfSA_PerceivedItem>>& GetPrioritizedTargetItems() const
   {
      return mPrioritizedTargetItems;
   }

   std::list<UtWeakReference<WsfSA_PerceivedItem>>& GetPrioritizedTargetItems() { return mPrioritizedTargetItems; }

   const std::list<UtWeakReference<WsfSA_EntityPerception>>& GetPrioritizedTargetEntities() const
   {
      return mPrioritizedTargetEntities;
   }

   std::list<UtWeakReference<WsfSA_EntityPerception>>& GetPrioritizedTargetEntities()
   {
      return mPrioritizedTargetEntities;
   }

   const std::list<UtWeakReference<WsfSA_EntityPerception>>& GetPrioritizedAircraftTargetEntities() const
   {
      return mPrioritizedAircraftTargetEntities;
   }

   std::list<UtWeakReference<WsfSA_EntityPerception>>& GetPrioritizedAircraftTargetEntities()
   {
      return mPrioritizedAircraftTargetEntities;
   }

   const std::list<UtWeakReference<WsfSA_EntityPerception>>& GetPrioritizedMissileTargetEntities() const
   {
      return mPrioritizedMissileTargetEntities;
   }

   std::list<UtWeakReference<WsfSA_EntityPerception>>& GetPrioritizedMissileTargetEntities()
   {
      return mPrioritizedMissileTargetEntities;
   }

   const std::list<UtWeakReference<WsfSA_Group>>& GetPrioritizedTargetGroups() const
   {
      return mPrioritizedTargetGroups;
   }

   std::list<UtWeakReference<WsfSA_Group>>& GetPrioritizedTargetGroups() { return mPrioritizedTargetGroups; }

   WsfSA_PerceivedItem* BestTarget(double aSimTime);

   WsfSA_EntityPerception* BestTargetEntity(double aSimTime);

   WsfSA_EntityPerception* BestTargetAircraft(double aSimTime);

   WsfSA_EntityPerception* BestTargetMissile(double aSimTime);

   WsfSA_Group* BestTargetGroup(double aSimTime);
 
   // .......................................................................................................................
 
   // These functions support "track" related calculations

   std::vector<std::size_t> CurrentlyTrackedPlatformIds() const { return mCurrentlyTrackedPlatformIds; }

   std::vector<std::string> CurrentlyTrackedPlatformNames() const { return mCurrentlyTrackedPlatformNames; }

   bool IsCurrentlyBeingTracked(size_t aPlatformId) const;
 
   // .......................................................................................................................
 
   // These functions support perceived groups

   const std::list<WsfSA_Group*>& PerceivedGroups() const { return GetSAP()->GetData()->mCurrentlyPerceivedGroups; }

   const std::list<WsfSA_Group*>& FocusedGroups() const { return mFocusedGroups; }

   const std::list<WsfSA_Group*>& UnfocusedGroups() const { return mUnfocusedGroups; }

   void UpdateGroupFocusLists();

   void SortedGroups(int aSortingEnum, std::vector<WsfSA_Group*>& aGroups) const;

   WsfSA_Group* GetGroup(const std::string& aName) const;
 
   // .......................................................................................................................
 
   // These functions support situation assessment calculations

   std::string MissionTask() const { return mMissionTask; }
 
   enum AcceptableRiskLevel
   {
      LOW    = 0,
      MEDIUM = 1,
      HIGH   = 2
   };

   AcceptableRiskLevel AcceptableLevelOfRisk() const { return mAcceptableLevelOfRisk; }

   uint8_t AcceptableLevelOfRiskByte() const { return static_cast<uint8_t>(mAcceptableLevelOfRisk); }

   double Risk() const { return mRisk; }

   double Defensiveness() const { return mDefensiveness; }

   double Urgency() const { return mUrgency; }

   double SelfRisk() const { return mSelfRisk; }

   double FlightRisk() const { return mFlightRisk; }

   double PackageRisk() const { return mPackageRisk; }

   double MissionRisk() const { return mMissionRisk; }

   bool SupportingWeapon() const { return mSupportingWeapon; }

   bool IgnoreMissilesAsThreats() const { return mIgnoreMissilesAsThreats; }

   bool IgnoreBogiesAsThreats() const { return mIgnoreBogiesAsThreats; }

   bool IgnoreMissilesAsTargets() const { return mIgnoreMissilesAsTargets; }

   bool IgnoreBogiesAsTargets() const { return mIgnoreBogiesAsTargets; }
 
   struct AircraftSignatureParameters
   {
      AircraftSignatureParameters()
         : fuselageFrontalArea(0.0)
         , wingArea(0.0)
         , tailArea(0.0)
         , engineInletArea(0.0)
         , engineExitArea(0.0)
         , sweepAngle(0.0)
         , signatureReductionFactorOverall(0.0)
         , signatureReductionFactorNose(0.0)
         , noseSignatureReductionAngle(0.0)
 
      {
      }
      AircraftSignatureParameters(double aFuselageFrontalArea,
                                  double aWingArea,
                                  double aTailArea,
                                  double aEngineInletArea,
                                  double aEngineExitArea,
                                  double aSweepAngle,
                                  double aSignatureReductionFactorOverall,
                                  double aSignatureReductionFactorNose,
                                  double aNoseSignatureReductionAngle)
         : fuselageFrontalArea(aFuselageFrontalArea)
         , wingArea(aWingArea)
         , tailArea(aTailArea)
         , engineInletArea(aEngineInletArea)
         , engineExitArea(aEngineExitArea)
         , sweepAngle(aSweepAngle)
         , signatureReductionFactorOverall(aSignatureReductionFactorOverall)
         , signatureReductionFactorNose(aSignatureReductionFactorNose)
         , noseSignatureReductionAngle(aNoseSignatureReductionAngle)
      {
      }
      double fuselageFrontalArea             = 0.0;
      double wingArea                        = 0.0;
      double tailArea                        = 0.0;
      double engineInletArea                 = 0.0;
      double engineExitArea                  = 0.0;
      double sweepAngle                      = 0.0;
      double signatureReductionFactorOverall = 0.0;
      double signatureReductionFactorNose    = 0.0;
      double noseSignatureReductionAngle     = 0.0;
   };
 
   // .......................................................................................................................
 
protected:
   WsfSA_Assess(const WsfSA_Assess&) = default;

   void CalculateTrackedPlatforms(double aSimTime);

   bool PlatformIsCurrentlyBeingTracked(size_t aTgtPlatformIndex) const;

   WsfLocalTrack* GetPerceivedTrackedPlatformWithTarget(size_t aTgtPlatformIndex);

   void CalculateOverallRisks(double aSimTime);

   void CalculateOverallDefensiveness(double aSimTime);

   void CalculateOverallUrgency(double aSimTime);

   double CalculateThreatLevel(double aSimTime, WsfSA_PerceivedItem* aThreatItem, bool aIsBogie);

   double CalculateTargetValue(double aSimTime, WsfSA_PerceivedItem* aTargetItem, bool aIsBogie);

   double CalculateMissileThreatLevel(double aSimTime, WsfSA_EntityPerception* aThreatItem, bool aIsBogie);

   double CalculateMissileTargetValue(double aSimTime, WsfSA_EntityPerception* aTargetItem, bool aIsBogie);

   double CalculateRisk(double aSimTime, WsfSA_EntityPerception* aThreatItem);

   double CalculateDefensiveness(double aSimTime, WsfSA_EntityPerception* aThreatItem);

   double CalculateUrgency(double aSimTime, WsfSA_EntityPerception* aThreatItem);
 
   // This structure is used internally by threat and target scoring and prioritization
   struct PlatormScorePairing
   {
      PlatormScorePairing() {}
      explicit PlatormScorePairing(WsfPlatform* aPlatform) { platform = aPlatform; }
      PlatormScorePairing(WsfPlatform* aPlatform, double aScore)
      {
         platform = aPlatform;
         score    = aScore;
      }
 
      WsfPlatform* platform = nullptr;
      double       score    = 0.0;
   };
 
   static bool CompareScore(const PlatormScorePairing& first, const PlatormScorePairing& second);

   double ExecuteCalculateRisk(double aSimTime);

   double ExecuteCalculateSelfRisk(double aSimTime);

   double ExecuteCalculateFlightRisk(double aSimTime);

   double ExecuteCalculatePackageRisk(double aSimTime);

   double ExecuteCalculateMissionRisk(double aSimTime);

   double ExecuteCalculateDefensiveness(double aSimTime);

   double ExecuteCalculateUrgency(double aSimTime);

   double ExecuteCalculateEntityThreatLevel(double aSimTime, WsfSA_EntityPerception* aThreatItem, bool aIsBogie);

   double ExecuteCalculateEntityTargetValue(double aSimTime, WsfSA_EntityPerception* aTargetItem, bool aIsBogie);

   double ExecuteCalculateMissileThreatLevel(double aSimTime, WsfSA_EntityPerception* aThreatItem, bool aIsBogie);

   double ExecuteCalculateMissileTargetValue(double aSimTime, WsfSA_EntityPerception* aTargetItem, bool aIsBogie);

   double ExecuteCalculateGroupThreatLevel(double aSimTime, WsfSA_Group* aThreatItem, bool aIsBogie);

   double ExecuteCalculateGroupTargetValue(double aSimTime, WsfSA_Group* aTargetItem, bool aIsBogie);

   bool ExecuteCalcWeaponSupport(double aSimTime);
 
private:
   struct MissilePkParameters
   {
      MissilePkParameters(double aNominalPk, double aHeadOnReduction, double aBroadsideReduction)
         : nominalPk(aNominalPk)
         , headOnReduction(aHeadOnReduction)
         , broadsideReduction(aBroadsideReduction)
      {
      }
      double nominalPk          = 0.0;
      double headOnReduction    = 0.0;
      double broadsideReduction = 0.0;
   };
 
   struct MissileWezParameters
   {
      MissileWezParameters(double                     aAvgSpeed,
                           double                     aMaxTimeFlight,
                           double                     aMaxOffBoresightAngle,
                           double                     aMinTimeFlight,
                           const MissilePkParameters& aPkData)
         : avgSpeed(aAvgSpeed)
         , maxTimeFlight(aMaxTimeFlight)
         , maxOffBoresightAngle(aMaxOffBoresightAngle)
         , minTimeFlight(aMinTimeFlight)
         , pkData(aPkData)
      {
      }
      MissileWezParameters(double aAvgSpeed,
                           double aMaxTimeFlight,
                           double aMaxOffBoresightAngle,
                           double aMinTimeFlight,
                           double aNominalPk,
                           double aHeadOnReduction,
                           double aBroadsideReduction)
         : avgSpeed(aAvgSpeed)
         , maxTimeFlight(aMaxTimeFlight)
         , maxOffBoresightAngle(aMaxOffBoresightAngle)
         , minTimeFlight(aMinTimeFlight)
         , pkData(aNominalPk, aHeadOnReduction, aBroadsideReduction)
      {
      }
      double              avgSpeed             = 0.0;
      double              maxTimeFlight        = 0.0;
      double              maxOffBoresightAngle = UtMath::cPI;
      double              minTimeFlight        = 0.0;
      MissilePkParameters pkData;
   };
 
   struct MissileRangeParameters
   {
      MissileRangeParameters()
         : range(0.0)
         , time(0.0)
         , pk(0.0)
      {
      }
      MissileRangeParameters(double aRange, double aTime, double aPk)
         : range(aRange)
         , time(aTime)
         , pk(aPk)
      {
      }
      double range = 0.0;
      double time  = 0.0;
      double pk    = 0.0;
   };

   bool SimpleWezCalculationAircraft(const WsfPlatform&      aTargetPlatform,
                                     MissileRangeParameters& aRmax,
                                     MissileRangeParameters& aRne,
                                     MissileRangeParameters& aRmin,
                                     double&                 aCurrentRange,
                                     bool&                   aEngageable) const;

   bool SimpleWezCalculationAircraft(const WsfPlatform&      aAircraftPlatform,
                                     const WsfPlatform&      aTargetPlatform,
                                     MissileRangeParameters& aRmax,
                                     MissileRangeParameters& aRne,
                                     MissileRangeParameters& aRmin,
                                     double&                 aCurrentRange,
                                     bool&                   aEngageable) const;

   bool SimpleMissileWezCalculation(const WsfPlatform&          aTargetPlatform,
                                    const MissileWezParameters& aMissileParameters,
                                    MissileRangeParameters&     aRmax,
                                    MissileRangeParameters&     aRne,
                                    MissileRangeParameters&     aRmin,
                                    double&                     aCurrentRange,
                                    bool&                       aEngageable) const;

   bool SimpleMissileWezCalculation(const WsfPlatform&          aAircraftPlatform,
                                    const WsfPlatform&          aTargetPlatform,
                                    const MissileWezParameters& aMissileParameters,
                                    MissileRangeParameters&     aRmax,
                                    MissileRangeParameters&     aRne,
                                    MissileRangeParameters&     aRmin,
                                    double&                     aCurrentRange,
                                    bool&                       aEngageable) const;

   bool LaunchComputerMissileWezLookup(const WsfPlatform&          aAircraftPlatform,
                                       const WsfPlatform&          aTargetPlatform,
                                       const MissileWezParameters& aMissileParameters,
                                       MissileRangeParameters&     aRmax,
                                       MissileRangeParameters&     aRne,
                                       MissileRangeParameters&     aRmin,
                                       double&                     aCurrentRange,
                                       bool&                       aEngageable) const;

   bool SimpleMissileWezCalculationInflight(const WsfPlatform&          aMissilePlatform,
                                            WsfPlatform&                aTargetPlatform,
                                            const MissileWezParameters& aMissileParameters,
                                            double&                     aRemainingRange,
                                            double&                     aRemainingTime,
                                            double&                     aPk) const;

   double SimpleCalcPkBasedOnAngleOff(const MissilePkParameters& aParameters, double aAngleOff) const;

   bool IsMediumRangeMissile(const std::string& aName) const;

   bool IsShortRangeMissile(const std::string& aName) const;

   double TargetCrossSection(const WsfPlatform& aTargetPlatform, double aAzimuth, double aElevation) const;
 
   // Script-based Functions
   // ..........................................................................................................
 
   UtScript* mCalculateRiskScriptPtr{nullptr};          
   UtScript* mCalculateSelfRiskScriptPtr{nullptr};      
   UtScript* mCalculateFlightRiskScriptPtr{nullptr};    
   UtScript* mCalculatePackageRiskScriptPtr{nullptr};   
   UtScript* mCalculateMissionRiskScriptPtr{nullptr};   
   UtScript* mCalculateDefensivenessScriptPtr{nullptr}; 
   UtScript* mCalculateUrgencyScriptPtr{nullptr};       
   UtScript* mCalculateEntityThreatLevelScriptPtr{
      nullptr}; 
   UtScript* mCalculateEntityTargetValueScriptPtr{
      nullptr}; 
   UtScript* mCalculateMissileThreatLevelScriptPtr{
      nullptr}; 
   UtScript* mCalculateMissileTargetValueScriptPtr{
      nullptr}; 
   UtScript* mCalculateGroupThreatLevelScriptPtr{
      nullptr}; 
   UtScript* mCalculateGroupTargetValueScriptPtr{
      nullptr}; 
   UtScript* mCalculateRiskPosedByEntityScriptPtr{
      nullptr}; 
   UtScript* mCalculateDefensivenessInducedByEntityScriptPtr{
      nullptr}; 
   UtScript* mCalculateUrgencyInducedByEntityScriptPtr{
      nullptr}; 
 
   // Movers and fuel objects
   // ..........................................................................................................
 
   WsfP6DOF_Mover*      mP6DofMover{nullptr};   
   wsf::six_dof::Mover* mSixDOF_Mover{nullptr}; 
   WsfBrawlerMover*     mBrawlerMover{nullptr}; 
   WsfBrawlerFuel*      mBrawlerFuel{nullptr};  
   WsfAirMover*         mAirMover{nullptr};     
   WsfFuel*             mAirMoverFuel{nullptr}; 
 
   // Weapon data
   // ......................................................................................................................
 
   UtScript*   mCalculateWeaponSupport{nullptr}; 
   std::string mSelectedWeapon;                  
   bool        mWeaponBayOpen{false};            
   bool        mSupportingWeapon{false};         
 
   // Perceived data and groups
   // ........................................................................................................
 
   const WsfSA_Processor::PerceiveData* mPerceivedDataSummary{
      nullptr}; 
   std::list<WsfSA_Group*> mFocusedGroups;
   std::list<WsfSA_Group*> mUnfocusedGroups;
 
   // Mission task, risk, defensiveness and urgency
   // ....................................................................................
 
   std::string         mMissionTask;                
   AcceptableRiskLevel mAcceptableLevelOfRisk{LOW}; 
   double              mRisk{0.0};                  
   double              mDefensiveness{0.0};         
   double              mUrgency{0.0};               
   double              mSelfRisk{0.0};              
   double              mFlightRisk{0.0};            
   double              mPackageRisk{0.0};           
   double              mMissionRisk{0.0};           
 
   // Prioritized threats and targets
   // ..................................................................................................
 
   unsigned int mMaxPrioritizedThreats{0};        
   unsigned int mMaxPrioritizedThreatsInitial{0}; 
   unsigned int mMaxPrioritizedTargets{0};        
   unsigned int mMaxPrioritizedTargetsInitial{0}; 
 
   std::list<UtWeakReference<WsfSA_PerceivedItem>>    mPrioritizedThreatItems;    
   std::list<UtWeakReference<WsfSA_EntityPerception>> mPrioritizedThreatEntities; 
   std::list<UtWeakReference<WsfSA_EntityPerception>> mPrioritizedAircraftThreatEntities; 
   std::list<UtWeakReference<WsfSA_EntityPerception>> mPrioritizedMissileThreatEntities;  
   std::list<UtWeakReference<WsfSA_Group>>            mPrioritizedThreatGroups;   
   std::list<UtWeakReference<WsfSA_PerceivedItem>>    mPrioritizedTargetItems;    
   std::list<UtWeakReference<WsfSA_EntityPerception>> mPrioritizedTargetEntities; 
   std::list<UtWeakReference<WsfSA_EntityPerception>> mPrioritizedAircraftTargetEntities; 
   std::list<UtWeakReference<WsfSA_EntityPerception>> mPrioritizedMissileTargetEntities;  
   std::list<UtWeakReference<WsfSA_Group>> mPrioritizedTargetGroups; 
 
   double mBogieThreatScoreMultiplier{1.0}; 
   double mBogieTargetScoreMultiplier{1.0}; 
 
   // Engagement data
   // ..................................................................................................................
 
   // Prioritized threats
   std::vector<size_t>      mPrioritizedThreatIds;   
   std::vector<std::string> mPrioritizedThreatNames; 
 
   // Prioritized targets
   std::vector<size_t>      mPrioritizedTargetIds;   
   std::vector<std::string> mPrioritizedTargetNames; 
 
   // Currently tracked platforms
   std::vector<size_t>      mCurrentlyTrackedPlatformIds;   
   std::vector<std::string> mCurrentlyTrackedPlatformNames; 
 
   // List of engagements
   std::vector<AssessEngagementData> mEngagementDataList; 
 
   // Temporary detection and WEZ range data
   // ...........................................................................................
 
   MissileWezParameters        mBlueMissileParametersMRM; 
   MissileWezParameters        mBlueMissileParametersSRM; 
   MissileWezParameters        mRedMissileParametersMRM;  
   MissileWezParameters        mRedMissileParametersSRM;  
   AircraftSignatureParameters mBlueAircraftSignature;    
   AircraftSignatureParameters mRedAircraftSignature;     
 
   // Other data
   // .......................................................................................................................
 
   bool   mIgnoreMissilesAsThreats{false}; 
   bool   mIgnoreBogiesAsThreats{false};   
   bool   mIgnoreMissilesAsTargets{true};  
   bool   mIgnoreBogiesAsTargets{true};    
   double mLastTimeCalculatedTrackedPlatforms{0.0}; 
 
   // ----------------------------------------------------------------------------------------------------------------------------------
};
 
#endif