WsfRouteMover.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.
// ****************************************************************************
// ****************************************************************************
// Updated by Infoscitex, a DCS Company.
// ****************************************************************************
 
#ifndef WSFROUTEMOVER_HPP
#define WSFROUTEMOVER_HPP
 
#include "wsf_export.h"
 
#include "WsfEvent.hpp"
#include "WsfMover.hpp"
class WsfPathFinder;
#include "WsfRandomVariable.hpp"
#include "WsfRoute.hpp"
class WsfRouteComputer;
#include "WsfWaypoint.hpp"
struct WsfPathConstraints;
 
namespace wsf
{
class Terrain;
}

class WSF_EXPORT WsfRouteMover : public WsfMover
{
public:
   enum MissTurnOption
   {
      cCLOSEST_POINT = 0,
      cREVERSE_TURN  = 1,
      cSKIP_POINT    = 2
   };
 
   WsfRouteMover() = delete;
   WsfRouteMover(const WsfScenario& aScenario);
   WsfRouteMover(const WsfRouteMover& aSrc);
   WsfRouteMover& operator=(const WsfRouteMover&) = delete;
   ~WsfRouteMover() override;
 
   bool Initialize(double aSimTime) override;
   bool Initialize2(double aSimTime) override;
   void Update(double aSimTime) override;
   bool ProcessInput(UtInput& aInput) override;
 
   void TurnOff(double aSimTime) override;
   void TurnOn(double aSimTime) override;
 
   const WsfRoute* GetRoute() const override { return &mRoute; }
 
   const WsfRoute* GetDefaultRoute() const override { return &mDefaultRoute; }
 
   int RoutePointIndex() const override { return mTargetIndex; }
 
   bool SetRoute(double aSimTime, const WsfRoute& aRoute) override { return SetRoutePoint(aSimTime, aRoute, 0); }
 
   bool GoToLabel(double aSimTime, WsfStringId aLabelId) override;
 
   bool GoToWaypoint(double aSimTime, unsigned int aDestination) override;
 
   bool GoToClosestPoint(double aSimTime) override;
 
   bool FindAndSetPath(double aSimTime, WsfGeoPoint* aStartPtr, WsfGeoPoint* aEndPtr) override;
 
   bool GoToLocation(double aSimTime, double aLatitude, double aLongitude, double aAltitude) override;

   virtual void Pause(double aSimTime, double aUnpauseTime) = 0;
 
   virtual bool Unpause(double aSimTime, bool aInterrupt);
 
   bool UpdateRoute(double aSimTime, const WsfRoute& aRoute) override;
 
   bool UpdateDefaultRoute() override;
 
   virtual bool SetRoutePoint(double aSimTime, const WsfRoute& aRoute, int aTargetPoint);
 
   bool ReturnToRoute(double aSimTime) override;

   bool IsPaused() const override;
 
   WsfRouteComputer* GetRouteComputer() const { return mRouteComputerPtr; }
   void              SetRouteComputer(WsfRouteComputer* aRouteComputerPtr);

   void SetEndOfPath(WsfPath::EndPath aEndOfPathOption) { mEndOfPath = aEndOfPathOption; }

   int  GetTargetIndex() const { return mTargetIndex; }
   void SetTargetIndex(int aIndex) { mTargetIndex = aIndex; }
   int GetCurrentIndex() const { return mCurrentIndex; }
 
   bool GoToSpeed(double aSimTime, double aSpeed, double aLinearAccel, bool aKeepRoute) override;
 
   MissTurnOption                    GetTurnFailOption() const { return mTurnFailOption; }
   double                            GetTurnFailThreshold() const { return mTurnFailureThreshold; }
   WsfPath::Switch                   GetSwitch() const { return mSwitch; }
   virtual const WsfPathConstraints* GetMoverConstraints() const;
 
   class UnpauseEvent : public WsfEvent
   {
   public:
      UnpauseEvent(WsfRouteMover* aMoverPtr, double aUnpauseTime)
         : WsfEvent(aUnpauseTime)
         , mMoverPtr(aMoverPtr)
         , mEnabled(true)
      {
      }
 
      // If this event is deleted
      ~UnpauseEvent() override
      {
         if (mEnabled)
         {
            mMoverPtr->mUnpauseEventPtr = nullptr;
         }
      }
 
      EventDisposition Execute() override
      {
         if (mEnabled)
         {
            mEnabled = false;
            mMoverPtr->TriggerUnpause(GetTime());
         }
         return cDELETE;
      }
 
      void Disable() { mEnabled = false; }
 
   private:
      WsfRouteMover* mMoverPtr;
      bool           mEnabled;
   };
 
protected:
   void TriggerUnpause(double aSimTime);
 
   void            SetAltRef(WsfPath::AltRef aAltRef) { mAltRef = aAltRef; }
   WsfPath::AltRef GetAltRef() const { return mAltRef; }
 
   // bool RouteIsValid(double          aSimTime,
   //                   const WsfRoute& aRoute);

   virtual void SetGuidanceFrom(const WsfWaypoint& aPreviousWaypoint) = 0;

   virtual void SetGuidanceTo(const WsfWaypoint& aNextWaypoint) = 0;

   virtual void AdvanceToNextWaypoint(double aSimTime, const WsfWaypoint& aTarget, const WsfWaypoint* aNextPointPtr) = 0;
 
   virtual void UpdatePosition(double aSimTime) = 0;
 
   virtual void WaypointReached(double aSimTime);
 
   void RouteChanged();
 
   bool IsSwitchingPoints() { return mProcessPointStage != -1; }
 
   void AddUnpauseEventFor(WsfRouteMover* aMoverPtr, double aUnpauseTime);
   void DisableAndClearUnpause();
 
   wsf::Terrain* mTerrainPtr;
   bool mForceUpdates;

   MissTurnOption mTurnFailOption;
   double mTurnFailureThreshold;
   mutable double mUnpauseTime;

   double mAltitudeOffset;
 
private:
   void InitializeUnpauseTime() const;
 
   void NormalizeRoute(WsfRoute& aRoute, bool aIsInitialRoute);
 
   void DoAdvanceToNextWaypoint(double aSimTime);
 
   int GetNextWaypointIndex(int aPointIndex);
 
   bool ProcessNextPoint(double aSimTime);
 
   bool ProcessNextPointStage(double aSimTime);
 
   bool ExecuteTriggers(double aSimTime, unsigned int aPointIndex) override;
 
   void ExecuteEndOfPath(double aSimTime, const WsfWaypoint& aEndPoint);
 
   void DrawDebugRoute();

   bool mIsInitialized;
   bool mUpdating;
   bool mDisableTerrain;
   bool mPrintRoutes;
   bool mDrawRoutes;
   int mProcessPointStage;
   int mCurrentIndex;
   int mTargetIndex;
   WsfRoute mRoute;
   WsfPath::Switch mSwitch;
   WsfStringId mStartLabelId;
 
   WsfRoute mDefaultRoute;
   int mLastRouteTargetIndex;
   WsfPath::EndPath mEndOfPath;
 
   WsfRouteComputer* mRouteComputerPtr;

   UnpauseEvent* mUnpauseEventPtr;

   WsfPath::AltRef mAltRef;

   mutable WsfRandomVariable mStartTime;
};
 
#endif