WsfBrawlerProcessor.hpp

Go to the documentation of this file.

// ****************************************************************************
// CUI//REL TO USA ONLY
//
// 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.
// ****************************************************************************
//****************************************************************************
// Updated by Infoscitex, a DCS Company
//****************************************************************************
 
#ifndef WSFBRAWLERPROCESSOR_HPP
#define WSFBRAWLERPROCESSOR_HPP
 
#include "wsf_brawler_export.h"
 
#include "BrawlerPlatform.hpp"
#include "UtInput.hpp"
#include "UtTable.hpp"
#include "UtVec3.hpp"
#include "WsfBrawlerComponents.hpp"
class WsfDraw;
class WsfLocalTrack;
class WsfPerceptionProcessor;
class WsfPlatform;
#include "WsfQuantumTaskerProcessor.hpp"
class WsfScenario;
#include "WsfSimpleComponent.hpp"
#include "WsfStringId.hpp"
class WsfThreatProcessor;
class WsfTrack;
 
// A component that adds brawler related capability to the platform.
// This component should only be added to a platform if the platform has brawler attributes
class WSF_BRAWLER_EXPORT WsfBrawlerProcessor : public WsfQuantumTaskerProcessor, public BrawlerPlatform
// public WsfSimplePlatformComponent
{
public:
   // static void RegisterComponentFactory(WsfScenario& aScenario);
   static WsfBrawlerProcessor* Find(const WsfPlatform& aPlatform);
 
   WsfBrawlerProcessor(WsfScenario& aScenario);
   WsfBrawlerProcessor(const WsfBrawlerProcessor& aSrc);
   WsfBrawlerProcessor& operator=(const WsfBrawlerProcessor&) = delete;
   ~WsfBrawlerProcessor() override;
 
   const char* GetScriptClassName() const override { return "WsfBrawlerProcessor"; }


   WsfComponent* CloneComponent() const override { return Clone(); }
   const int*    GetComponentRoles() const override;
   void*         QueryInterface(int aRole) override;
   // virtual void          ComponentParentChanged(WsfPlatform* aPlatformPtr) { mPlatformPtr = aPlatformPtr; }
 
   bool          Initialize(double aSimTime) override;
   bool          ProcessInput(UtInput& aInput) override;
   WsfProcessor* Clone() const override;
 
   // virtual void Update(double aSimTime);



   double GetTime() override;

   void UpdateMissileMode() override;

   bool HaveWeapons() override;

   virtual void SetLocationWCS(const double aLocationWCS[3]);
   virtual void SetLocationECI(const double aLocationWCS[3]);
   virtual void SetLocationLLA(double aLat, double aLon, double aAlt);
 
   using BrawlerPlatform::GetSpeed; // ft/s

   double MindUpdate(double aSimTime) override;

   WsfPerceptionProcessor* GetPerceptionProcessor() const { return mPerceptionProcessorPtr; }
   WsfThreatProcessor* GetThreatProcessor() const { return mThreatProcessorPtr; }

   double GetConsciousnessEventTime() override;

   void SetNextConsciousnessEventTime(double aSimTime)
   {
      mLastConsciousnessEventTime = mNextConsciousnessEventTime;
      mNextConsciousnessEventTime = aSimTime;
   }
   double GetNextConsciousnessEventTime() { return mNextConsciousnessEventTime; }

   void AddSelfCalledConsciousnessEvent(double aEventTime);


   // brawler aero command type 1
   double EvaluateRates(UtVec3d& aAngularRates,                // Radians/sec
                        UtVec3d& aLongitudinalAccel) override; // Meters/sec^2
 
   // brawler aero command type 2
   double EvaluateHeadingSpeedAltitude(const double& aHeading,            // degrees
                                       const double& aSpeed,              // meters/sec
                                       const double& aAltitude,           // meters
                                       const double& aMaxGees,            // Gs
                                       const double& aMaxClimb) override; // meters/sec
   // brawler aero command type 3
   double EvaluateTurnInPlaneWithSpeed(UtVec3d&      aPlane,                 // World coordinates, meters
                                       const double& aGees,                  // Gs
                                       const double& aSpeed) override;       // meters/sec
   double EvaluateTurnInPlaneWithThrottle(UtVec3d&      aPlane,              // World coordinates, meters
                                          const double& aGees,               // Gs
                                          const double& aThrottle) override; //[0-3]
   // brawler aero command type 4
   double EvaluateVectorWithSpeed(UtVec3d&      aVelocityVector,        // Directional unit vector
                                  const double& aMaxGees,               // Gs
                                  const double& aSpeed) override;       // meters/sec
   double EvaluateVectorWithThrottle(UtVec3d&      aVelocityVector,     // Directional unit vector
                                     const double& aMaxGees,            // Gs
                                     const double& aThrottle) override; //[0-3]
 
   virtual double EvaluateAlternative(UtEntity& projectedState);


   double SensorGimbalElevationLimit() override;
   double SensorGimbalAzimuthLimit() override;



   // Forward Acceleration Functions
   double MaxForwardAcceleration_fps2() override;
   double MinForwardAcceleration_fps2() override;
   double MaxForwardAccelerationWithGravity_fps2() override;
   double MinForwardAccelerationWithGravity_fps2() override;
   // Maximum Performance Turn Functions
   double MaxInstantaneousGLoad_g() override;
   double MinInstantaneousTurnRadius_ft() override;
   double MaxInstantaneousTurnRate_rps() override;
   double MaxSustainedGLoad_g() override;
   double MinSustainedTurnRadius_ft() override;
   double MaxSustainedTurnRate_rps() override;
   // Comfortable Turn Functions
   double MaxTacticalGLoad_g() override;
   double MinTacticalTurnRadius_ft() override;
   double MaxTacticalTurnRate_rps() override;
   // Misc Performance Calculations
   double CorneringVelocity_fps() override;
   double SpecificEnergyRate_fps() override;
   double CalcTurnRate_rps(const double& aClMax,
                           const double& aSpeed_fps,
                           const double& aDynamicPressure_psf,
                           const double& aWingArea_ft2) override;
   // Weights
   double CurrentWeight_lbs() override;
   double EmptyWeight_lbs() override;
   double CurrentFuelWeight_lbs() override;
   double DesignWeightForMaxG_lbs() override;
   // Structural Limits
   double CurrentStructuralGLimit_g() override;
   double StructuralGLimitAtDesignWeight_g() override;
   double StructuralGLimitAboveDesignWeight_g() override;
   // Data Functions
   double DynamicPressure_psf() override;
   double Mach() override;
   double GetMaxCL() override;
   double GetMaxCL(const double& aMach) override;
   double GetMaxCL(const double& aAlt_ft, const double& aMach) override;
   double GetAlphaAtMaxCL_deg() override;
   double GetAlphaAtMaxCL_deg(const double& aMach) override;
   double GetAlphaAtMaxCL_deg(const double& aAlt_ft, const double& aMach) override;
   double MaxAngularRate_rps() override;
 
   virtual double Lift(const double& alpha,     // degrees (angle of attack)
                       const double& speed,     // meters/sec
                       const double& altitude); // meters
 
   virtual double Drag(const double& alpha,     // degrees (angle of attack)
                       const double& speed,     // meters/sec
                       const double& altitude); // meters
 
   virtual double Thrust(const double& throttle,  // setting [1-3]
                         const double& speed,     // meters/sec
                         const double& altitude); // meters
 
   virtual double Throttle(); // setting [1-3]
 
   // virtual double Weight(); //use: CurrentWeight_lbs()
   // virtual double DynamicPressure(); //use:       virtual double DynamicPressure_psf()
   virtual double Area();     // reference area or surface area (sq feet)
   virtual double Alpha();    // angle of attack, degrees
   virtual double AlphaCL0(); // alpha at zero lift (aircraft flying flat)
 
protected:

   WsfLocalTrack* GetTargetTrack();
   UtEntity*      GetTarget() override;                          // over-write
   double         FirstObservedTime(UtEntity* aTgtPtr) override; // over-write
   UtEntity*      GetThreat() override;                          // over-write
   int            GetNumberThreats() override;                   // over-write
 
private:
   // WsfPlatform*                     mPlatformPtr;

   WsfPerceptionProcessor* mPerceptionProcessorPtr;

   WsfThreatProcessor* mThreatProcessorPtr;

   bool mFirstCE;

   double mNextConsciousnessEventTime;

   double mLastConsciousnessEventTime;

   double mUserConsciousnessEventDT;

   double LastConsciousnessEventTime() override { return mLastConsciousnessEventTime; } // replaces use of "tlstce"
 
   UtTable::Curve* mCLMaxVsMachTablePtr;        
   UtTable::Curve* mAlphaAtCLMaxVsMachTablePtr; 
 
   double mStructuralGLimitAboveDesignWeight_g; 
 
   bool     mDebug;                  
   bool     mDebugDrawAlternatives;  
   bool     mDebugDrawNominalStates; 
   WsfDraw* mDrawPtr;                
 
   double mAlternativeMinScore; 
   double mAlternativeMaxScore; 

   UtVec3d GetEvaluationColor(double aScore);

   void     PopulateEntityFromTrack(UtEntity& aEntity, WsfTrack* aTrackPtr);
   UtEntity mTargetEntity; 
   UtEntity mThreatEntity; 
};
 
WSF_DECLARE_COMPONENT_ROLE_TYPE(WsfBrawlerProcessor, cWSF_COMPONENT_BRAWLER_PROCESSOR)
 
#endif