humanMoveToController.h

Go to the documentation of this file.

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


#pragma once

#include "vrfmodel/vrfmodelDefines.h"
#include "vrfobjcore/singleTaskControllerComponent.h"
#include "vrfobjcore/humanLocalObjectFacade.h"

class DtCgf;
class DtHumanStateRepository;
class DtSimMessage;
class DtHumanMoveToPSR;
class DtCollisionInputPort;
class DtInputPortGroup;
class DtHumanMovementControlOutputPortGroup;
class DtVectorOutputPort;
class DtHumanMoveToControllerDescriptor;
class DtBooleanOutputPort;
class DtActiveBotNavInterface;
class DtGenericPsr;
class DtAnalogInputPort;
class DtAnalogOutputPort;
class DtVectorInputPort;

class DT_DLL_vrfmodel DtHumanMoveToController : public DtSingleTaskControllerComponent
{
private:
   DtHumanMoveToController();
   DtHumanMoveToController(const DtHumanMoveToController& orig);
   DtHumanMoveToController& operator=(const DtHumanMoveToController& orig);
public:
   DtHumanMoveToController(const DtString& name, DtLocalObject* owner, DtSimulationServices* simManager, DtComponentDescriptor* desc=nullptr, DtReaderWriterRegistry *parentRegistry=nullptr);

   virtual ~DtHumanMoveToController();

   virtual bool init() override;

   virtual const char* type() const override;

   virtual void tick() override;

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

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

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

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

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

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

protected:

   virtual void processMoveToTask(DtSimMessage * msg);


   virtual void processMoveToLocationTask(DtSimMessage * msg);

   virtual void processMoveToDestinationTask(DtSimMessage* msg);

   virtual void processDestinationChanged();

   virtual bool setupDestination();

   virtual void setupDestinationVector() const;

   virtual void invalidateDestinationVector() const;

   virtual bool atDestination();

   virtual void doMoving();

   virtual double findDesiredHeading();

   virtual double findDesiredSpeed();

   virtual void moveToDestination();

   virtual void stop(bool success);

   virtual void registerTaskMsgCallbacks() override;

   virtual void processModifyVrfObject(DtSimMessage* msg);

   virtual void processSetLocation(DtSimMessage* msg);

   virtual bool createPortGroups() override;

   virtual bool createPorts() override;

   virtual bool createPSR();

   virtual double distanceToDestination() const;

   virtual void clearTask() override;

   virtual bool destinationIsInsideObstruction(
      const DtVector& localDestination) const;

   virtual bool decideToGiveUpTask() const override;

   virtual double atDistance() const;

   virtual bool usingNavBot() const;

   virtual void useNavBotData();

   virtual unsigned maxNumFailedPathAttempts() const;

   virtual bool findAlternateDestination();

   virtual void setStuck(bool yesNo);
   virtual double stuckTime();

   static void navAreaChangedCallback(void* usr);
   virtual void processNavAreaChanged();

   DtVector localDestination() const;

   virtual void updateTaskVisualizations() override;

   virtual void suspendTask() override;

   virtual void preFirstTickInit() override;

   static void setAiEnabledCallback(DtSimMessage* msg, void* usrData);
   virtual void processSetAiEnabled(DtSimMessage* msg);

   virtual void processNavigationInterfaceChanged();

   virtual void processEstimatedTotCalculation();

   template<typename T_Task>
   void setCommonTaskParams(const T_Task& task)
   {
      myOverrideAtDistance = task.isAtDistanceSpecified();
      if (myOverrideAtDistance)
      {
         myOverrideAtDistanceValue = task.atDistance();
      }
      myOverrideSpeed = task.isSpeedSpecified();
      if (myOverrideSpeed)
      {
         myOverrideSpeedValue = task.speed();
      }
   }

   virtual bool currentPathEdge(DtVector& pathEdgeStart, DtVector& pathEdgeEnd) const;

protected:


   DtCollisionInputPort*   myCollisionAvoidancePort;

   DtInputPortGroup*       myCollisionAvoidancePortGroup;

   DtHumanMovementControlOutputPortGroup* myHumanMovementControlOutputPortGroup;

   DtVectorOutputPort* myDestinationOutputPort;

   DtBooleanOutputPort* myIsMovingPort;

   DtBooleanOutputPort* myUseCollisionAvoidancePort;

   DtVectorInputPort* myLastVertexLocationInputPort;

   DtAnalogInputPort* myEtaForLastVertexInputPort;

   DtAnalogOutputPort* myEtaToLastVertexOutputPort;


   DtSimObjectReference     myControlPoint;

   DtVector          myLocalDestination;
   DtVector          myWorldDestination;

   bool              myHasIntermediateDestination;
   DtVector          myIntermediateWorldDestination;
   DtVector          myIntermediateLocalDestination;

   mutable DtVector  myDestinationVector;
   mutable bool      myDestinationVectorIsValid;

   bool              myAtDestination;
   double            myDistanceSquared;

   bool              myOverrideAtDistance;
   double            myOverrideAtDistanceValue;
   bool              myOverrideSpeed;
   double            myOverrideSpeedValue;

   //Used to force the navigation interface to be ignored.
   //This is useful when the nav interface has given us a partial
   //path to the destination (for example, if we're in a nav area
   //but our destination is outside the nav area).
   //Once set, gets reset when any of the following happen:
   //1) A new task is issued
   //2) The destination location changes
   //3) A set location occurs
   //4) The entity moves to a new navArea.
   bool              myIgnoreNavData;

   unsigned myNumFailedPathAttempts;

   DtHumanStateRepository* myHumanStateRepository;

   DtHumanMoveToPSR* myProcessState;
   //DtGenericPsr* myHumanMovePsr;

   DtHumanMoveToControllerDescriptor* myHumanMoveToControllerDescriptor;
   DtActiveBotNavInterface* myNavInterface;

   bool myAIEnabled;

   const double DtEstimatedTotCalcInterval = 5.0;

   bool myEstimatedTotCalcEnabled;
   double myEstimatedTotValue;
   double myEstimatedTotLastCalcTime;
   DtVector myEstimatedTotTextPos;

   DtHumanLocalObjectFacade myHumanLocalObjectFacade;
};

void registerDtHumanMoveToController(DtCgf* cgf);