disaggregatedManeuverAlongController.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2004 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/



#pragma once

#include <vlutil/vlConfig.h> 
#include <vector>

#include "vrfobjcore/singleTaskControllerComponent.h"
#include "vrfobjcore/aggregateLocalObjectFacade.h"
#include "vrfmodel/entityRouteFollowingData.h"
#include "vrfmodel/entityRouteTraversalState.h"

class DtVrfAggregateStateRepository;
class DtFormationState;
class DtMoveAlongTask;
class DtSimMessage;
class DtAggregateMoveAlongPSR;
class DtAggregateMoveAlongDescriptor;
class DtSetDataRequest;
class DtVrfObjectManager;
class DtCompatibilityRadio;

#include "vrfmodel/vrfmodelDefines.h"
class DT_DLL_vrfmodel DtDisaggregatedManeuverAlongController : public DtSingleTaskControllerComponent
{
public:

   DtDisaggregatedManeuverAlongController (const DtString& name, 
      DtLocalObject* owner,
      DtSimulationServices* simManager, 
      DtComponentDescriptor* desc = 0,
      DtReaderWriterRegistry* parentRegistry = 0);


   virtual ~DtDisaggregatedManeuverAlongController() override;

   virtual const char* type() const override;

   virtual bool init() override;

   virtual void registerTaskMsgCallbacks() override;

   virtual void preFirstTickInit() override;

   virtual void tick() override;

   virtual void clearTask() override;

   virtual bool createPSR();

   virtual DtSimTaskStatePtr currentTaskState() const override;

   static void maneuverAlongCallback(DtSimMessage* msg, void* usr, DtSimTaskStatePtr taskStatePtr);

   static void taskCompleteReportCallback(DtSimMessage * msg, void * usr);

   static void formationChangedCallback(const DtFormationState& formationState, 
      void* usr);

   static DtSimComponent * creator(const DtString& name, 
      DtLocalObject* owner,
      DtSimulationServices* simManager, 
      DtComponentDescriptor* desc = 0,
      DtReaderWriterRegistry* parentRegistry = 0);

protected:
   virtual bool originalIsSpeedSpecified() const;
   virtual double originalSpeed() const;
   virtual bool originalStartAtClosest() const;
   virtual bool originalUseForwardDirection() const;
   virtual DtUUID originalRouteUUID() const;

   virtual const DtSimTaskMessageType& originalTaskType() const;

   virtual void processManeuverAlong(const DtTaskMessage& msg, DtSimTaskStatePtr taskStatePtr);

   virtual void processFormationChanged(const DtFormationState& formationState);

   virtual void processTaskComplete(DtSimMessage * msg);

   virtual void processRouteChanged();

   virtual int sendTaskToSubordinate(const DtSimTask& task, 
      const DtUUID& subordinate);

   virtual void sendSetDataToSubordinate(const DtSetDataRequest& setData, 
      const DtUUID& subordinate) const;

   virtual void beginManeuverAlong(const DtUUID& routeName,
      const bool startAtClosestPoint, const bool traverseForward);

   virtual int findClosestSegmentIndex(DtVector testPoint, std::vector<DtVector> testRoute,
      DtPoint& closestSegmentLoc, double& distanceToSegment, int indexSegmentFloor = 0);

   virtual bool createSubordinateOffsetRoute(
      const std::vector<DtVector>& localPoints, 
      const double rightOffset, const double forwardOffset, 
      DtUUID& routeUUID, DtUUID subordinateId);

   virtual bool isPlatform(const DtSimObjectReference& subject) const;

   virtual bool isSubordinateCapable(const DtUUID& sub) const;

   virtual bool isSubUnit(const DtSimObjectReference& subject) const;

   virtual int taskLeader(const DtUUID& leader, const DtSimObjectReferenceList& subs,
      const DtUUID& leaderRoute, 
      const double formationWidth, const double formationLength);

   virtual int taskFollower(const DtUUID& subEntity, const DtUUID& formationLeader,
      const DtUUID& unitRouteUUID, const double leaderForwardOffset,
      const bool doReverseRoute, const double vertexStartIndex);

   virtual int taskSubunit(const DtUUID& subUnitId);

   virtual int taskSubunit(const DtUUID& subUnitId, const DtUUID& routeId);

   virtual void sendVrfObjectModifyMsg(const DtUUID& object, DtList* vertices) const;

   virtual void initializeMemberDataFromDescriptor(
      const DtAggregateMoveAlongDescriptor& desc);

   virtual bool isUnitMovementExhausted();

   virtual void sendClearTask(const DtUUID& recipient, const DtSimTaskMessageType& taskType) const;

   virtual bool publishFormationRoutes() const;

   virtual double dist2D(const DtVector& position1, const DtVector& position2,
      const Coordinate_System& coordinateSystem);


private:

   DtDisaggregatedManeuverAlongController();

   DtDisaggregatedManeuverAlongController(const DtDisaggregatedManeuverAlongController& orig);

   DtDisaggregatedManeuverAlongController& operator=(const DtDisaggregatedManeuverAlongController& orig);

protected:

   std::map<int, DtString> myPromotionIndexRouteNameMap;

   std::map<const DtSimObject*, DtEntityRouteFollowingData> myEntityRouteFollowingMap;

   std::map<const DtSimObject*, DtEntityRouteTraversalState> myEntityRouteTraversalStateMap;

   DtVrfAggregateStateRepository* myAggregateStateRepository;

   DtFormationState* myFormationState;

   DtCompatibilityRadio* myCommandRadio;

   bool myGenerateRoutesWithRoundedCorners;

   double myVertexSpacingAlongRoundedCorners;

   DtAggregateMoveAlongPSR* myProcessState;

   const DtAggregateMoveAlongDescriptor* myAggregateMoveAlongDescriptor;

   bool myRegisteredFormationChangedCallback;

   unsigned int myNextRouteIndex;

   DtSimTaskStatePtr myCachedTaskState;

   bool mySetObjectToBeRemovedCallbacks;

   DtSimObjectReference myRoute;

   bool myRestartTaskOnFormationUpdate;

   DtTime myStuckSubordinatesGiveUpSimTime;
};