WsfSA_Perceive.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 WSFSA_PERCEIVE_HPP
#define WSFSA_PERCEIVE_HPP
 
#include "wsf_air_combat_export.h"
 
#include <random>
#include <set>
 
#include "WsfSA_GroupManager.hpp"
#include "WsfSA_Module.hpp"
class WsfExplicitWeapon;
class WsfSA_Processor;
#include <unordered_map>
#include <unordered_set>
 
#include "WsfTrackId.hpp"

class WSF_AIR_COMBAT_EXPORT WsfSA_Perceive : WsfSA_Module
{
public:
   friend class WsfSA_Processor;
   friend class WsfSA_ProcessorUpdateEvent;
 
   enum RecipientType
   {
      cCOMMANDER       = 1,
      cPEERS           = 2,
      cSUBORDINATES    = 4,
      cALLCOMMANDERS   = 8,
      cALLSUBORDINATES = 16
   };
 
   WsfSA_Perceive(WsfSA_Processor* aSA_ProcPtr, WsfSA_Processor::PerceiveData* aDataPtr);
   WsfSA_Perceive& operator=(const WsfSA_Perceive&) = delete;
   ~WsfSA_Perceive();

   void AddExtraCognitiveLoading(double aTimeDelay);

   void MarkAssetAsImportant(WsfPlatform& aAsset);

   void MarkAssetAsImportant(size_t aIndex);

   void MarkAssetTypeAsImportant(const std::string& aType);

   void MarkAssetTypeAsUnimportant(const std::string& aType);

   void MarkAssetAsUnimportant(WsfPlatform& aAsset);

   void MarkAssetAsUnimportant(size_t aIndex);

   void MarkThreatAsImportant(WsfLocalTrack& aThreat);

   void MarkThreatAsUnimportant(WsfLocalTrack& aThreat);

   void MarkThreatTypeAsImportant(const std::string& aType);

   void MarkThreatTypeAsUnimportant(const std::string& aType);

   int MaxAssetLoad() { return mDataPtr->mMaxAssetLoad; }

   int MaxThreatLoad() { return mDataPtr->mMaxThreatLoad; }

   const WsfSA_EntityPerception* PerceivedAsset(size_t aPlatformIndex) const;

   const std::vector<WsfSA_EntityPerception*>& PerceivedAssets(double aSimTime);

   const std::vector<WsfSA_EntityPerception*>& PerceivedAircraftAssets(double aSimTime);

   const std::vector<WsfSA_EntityPerception*>& PerceivedMissileAssets(double aSimTime);

   const std::vector<WsfSA_EntityPerception*>& PerceivedBogies(double aSimTime);

   const std::vector<WsfSA_EntityPerception*>& PerceivedAircraftBogies(double aSimTime);

   const std::vector<WsfSA_EntityPerception*>& PerceivedMissileBogies(double aSimTime);

   const std::vector<WsfSA_EntityPerception*>& PerceivedBandits(double aSimTime);

   const std::vector<WsfSA_EntityPerception*>& PerceivedAircraftBandits(double aSimTime);

   const std::vector<WsfSA_EntityPerception*>& PerceivedMissileBandits(double aSimTime);

   WsfLocalTrack* PerceivedThreat(WsfStringId aTargetNameId);

   WsfLocalTrack* PerceivedThreat(const WsfTrackId& aTrackId);

   bool PossibleEnemy(WsfLocalTrack* aTrackPtr);

   bool ProcessInput(UtInput& aInput);

   bool ProcessMessage(double aSimTime, const WsfMessage& aMessage);

   void Initialize(double aSimTime);
 
   // Asset functions --------------------------------------------------------------------------------------

   void SetMaxAssetLoad(int aLoad) { mDataPtr->mMaxAssetLoad = aLoad; }

   void ResetMaxAssetLoad() { mDataPtr->mMaxAssetLoad = mDataPtr->mMaxAssetLoadInitial; }

   bool AssetScore(double aSimTime, WsfSA_EntityPerception* aEntityPtr, double& aScore);
 
   // Returns true if the entity is contained in the current asset list
   bool EntityIsInAssetGroup(const WsfSA_EntityPerception* aEntity) const;
 
   // Returns true if the entity index is contained in the current asset list
   bool EntityIsInAssetGroup(size_t aEntityIndex) const;
 
   // Purges old assets based on lifetime
   void PurgeOldAssets(double aSimTime);

   WsfSA_EntityPerception* NearestAsset(double aSimTime);

   WsfSA_EntityPerception* NearestAircraftAsset(double aSimTime);

   WsfSA_EntityPerception* NearestMissileAsset(double aSimTime);
 
   // Threat (Bogie and Bandit) functions ------------------------------------------------------------------

   void SetMaxThreatLoad(int aLoad) { mDataPtr->mMaxThreatLoad = aLoad; }

   void ResetMaxThreatLoad() { mDataPtr->mMaxThreatLoad = mDataPtr->mMaxThreatLoadInitial; }

   bool ThreatScore(double aSimTime, WsfLocalTrack* aThreatPtr, bool aIsMissile, double& aScore);

   double DefaultThreatScore(double aSimTime, WsfSA_PerceivedItem* aThreatPtr);

   WsfSA_EntityPerception* NearestBogie() const;

   WsfSA_EntityPerception* NearestAircraftBogie() const;

   WsfSA_EntityPerception* NearestMissileBogie() const;

   WsfSA_EntityPerception* NearestBandit() const;

   WsfSA_EntityPerception* NearestAircraftBandit() const;

   WsfSA_EntityPerception* NearestMissileBandit() const;
 
   // Miscellaneous functions ------------------------------------------------------------------------------

   std::set<WsfPlatform*> TruthAssets();


   std::string SelectedWeaponName() const;

   const WsfExplicitWeapon* SelectedWeapon() const;

   int QuantityOfSelectedWeapon() const;

   bool SetSelectedWeapon(const std::string& aWeaponName);

   const std::vector<WsfExplicitWeapon*> GetWeaponList() const { return mDataPtr->mWeaponList; }

   void SetMasterArm(bool aArmed);

   bool GetMasterArm() const;

   bool MasterWarningActive() const;

   bool MasterCautionActive() const;

   bool WeaponBayDoorsAreOpen() const;

   bool ShootCueActive() const;

   bool ShootCueBlinking() const;

   bool JammingDetected() const;

   void SetMasterWarningActive(bool aActive);

   void SetMasterCautionActive(bool aActive);

   void SetWeaponBayDoorsAreOpen(bool aOpen);

   void SetShootCueActive(bool aActive);

   void SetShootCueBlinking(bool aBlinking);

   void SetJammingDetected(bool aJammingDetected);


   bool EngagedTargetValid() const { return mDataPtr->mEngagedTarget.isValid; }

   WsfSA_Processor::SA_EngagedTarget GetEngagedTarget() const { return mDataPtr->mEngagedTarget; }

   void SetEngagedTarget(const WsfSA_Processor::SA_EngagedTarget& aEngagedTarget)
   {
      mDataPtr->mEngagedTarget = aEngagedTarget;
   }


   int QuantityOfChaff() const;

   int QuantityOfFlares() const;

   int QuantityOfDecoys() const;

   bool DispenseChaff(double aSimTime);

   bool DispenseFlare(double aSimTime);

   bool DispenseDecoy(double aSimTime);
 
   // Group functions

   bool RenameGroup(WsfSA_Group* aGroup, const std::string& aName);

   WsfSA_Group* CreateGroup(const std::list<WsfSA_EntityPerception*>& aElements, bool aProtect = false);

   bool DisbandGroup(WsfSA_Group* aGroup, bool aProtect = false);

   WsfSA_Group* MergeGroups(const std::list<WsfSA_Group*>& aGroups, bool aProtect = false);

   std::pair<WsfSA_Group*, WsfSA_Group*>
   SplitGroup(WsfSA_Group* aGroup, int aNumElements, int aCriterion, bool aProtect = false);

   bool TransferEntity(WsfSA_EntityPerception* aEntity, WsfSA_Group* aGroup, bool aProtect = false);

   bool RemoveEntityFromGroup(WsfSA_EntityPerception* aEntity, bool aProtect = false);

   bool SetFocus(WsfSA_Group* aGroup, bool aFocus, bool aProtect = false);

   void SetImportant(WsfSA_PerceivedItem* aItem, bool aIsImportant);

   bool GetFocus(WsfSA_Group* aGroup);

   bool GetImportant(WsfSA_PerceivedItem* aItem);
 
protected:
   WsfSA_Perceive(const WsfSA_Perceive& aSrc);

   WsfSA_EntityPerception* NearestEntity(const std::vector<WsfSA_EntityPerception*>& aDataList) const;

   bool Important(WsfLocalTrack* aThreatPtr);

   bool Important(WsfPlatform* aAssetPtr);

   bool Important(size_t aPlatformIndex);

   bool Unimportant(WsfLocalTrack* aThreatPtr);

   bool Unimportant(WsfPlatform* aAssetPtr);

   bool Unimportant(size_t aPlatformIndex);

   void LocalTrackDropped(double aSimTime, const WsfLocalTrack* aLocalTrackPtr);

   double TryUpdateStatus(double aSimTime);

   double TryUpdateAssets(double aSimTime);

   double TryUpdatePerceivedItemData(double aSimTime);

   double TryUpdatePerceivedItemCalculation(double aSimTime);

   double UpdateStatus(double aSimTime);

   void UpdateAssets(double aSimTime);

   void UpdateAssetsData(double aSimTime);

   void UpdateGroupsData(double aSimTime);

   void UpdatePerceivedItemsCalculation(double aSimTime);

   void RemoveAnyInvalidEntitiesInBogiesAndBandits();

   void Prune(double aSimTime);

   void FindExpenableCountermeasures();

   void FindWeapons();

   void CreateAssetsList(double aSimTime, std::list<WsfSA_EntityPerception*>& aTempAssetsList, bool aUnlimitedAssets);

   void CreateBanditsList(double aSimTime, std::list<WsfSA_EntityPerception*>& aTrackedEntitiesList, bool aUnlimitedBandits);

   void CreateBogiesList(double aSimTime, std::list<WsfSA_EntityPerception*>& aTrackedEntitiesList, bool aUnlimitedBogies);

   double GetThreatScore(double aSimTime, WsfSA_EntityPerception* aThreatPtr, bool aIsMissile);

   void CreateAssetSublists();

   void CreateSublists();

   void RemoveExpiredCoastingPerceptions(std::vector<WsfSA_EntityPerception*>& aPerceptionList,
                                         double                                aCoastTime,
                                         double                                aSimTime);
 
   void SetOldPerceptionsAsCoasting(const std::vector<WsfSA_EntityPerception*>& aPerceptionList, double aSimTime);

   void UpdateCoastingPerceptions(const std::vector<WsfSA_EntityPerception*>& aPerceptionList,
                                  const std::list<WsfSA_EntityPerception*>&   aNewPerceptionList,
                                  double                                      aSimTime);

   void AddOrUpdatePerception(std::vector<WsfSA_EntityPerception*>& aPerceptionList,
                              WsfSA_EntityPerception&               aPerception,
                              double                                aSimTime);

   void JoinInitialGroups(std::vector<WsfSA_EntityPerception*>& aPerceptionList,
                          std::list<WsfSA_Group*>&              aGroupList,
                          double                                aSimTime);

   void DropEntity(WsfSA_EntityPerception* aOldEntity);

   void DeleteLater(WsfSA_EntityPerception* aOldEntity);

   void DeferredDelete();
 
private:
   std::list<WsfSA_EntityPerception*> mDeferredForDeletion;
 
   double mConsiderationRandomness{0.0};
 
   std::default_random_engine mRandom{};
   struct TrackDelayData
   {
      double mTimeAdded;
      bool   mIsVisual;
      bool   mIsDone;
   };
   std::unordered_map<WsfTrackId, TrackDelayData, WsfTrackId> mTrackDelayQueue;
 
   // Groups data
   // ......................................................................................................................
 
   WsfSA_GroupManager mGroupManager; 
 
   double mMaxGroupingDistanceCentroid{8.0 * UtMath::cM_PER_NM};      
   double mMaxGroupingDistanceNeighbor{4.0 * UtMath::cM_PER_NM};      
   double mMaxGroupingHeadingDifference{10.0 * UtMath::cRAD_PER_DEG}; 
   double mMaxGroupingSpeedDifference{100.0};                         
   double mMinGroupRadius{1.0 * UtMath::cM_PER_NM};                   
   bool   mUseCentroidGrouping{true};                                 
   bool   mUseNeighborGrouping{true};                                 
   bool   mUseHeadingGrouping{true};                                  
   bool   mUseSpeedGrouping{true};                                    
   bool   mUseTypeGrouping{false};                                    
   bool   mIgnoreBogiesWhenGrouping{false};                           
};
 
#endif