embarkationController.h

Go to the documentation of this file.

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

#pragma once

#include "vrfobjcore/singleTaskControllerComponent.h"
#include "vrfobjcore/vrfEmbarkationPSR.h"




class DtString;
class DtSimManager;
class DtTaskMessage;
class DtEmbarkationDescriptor;
class DtIfEmbarkationInformation;
class DtSetDataRequest;

#include <list>

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

   DtEmbarkationController(const DtString& name, 
      DtVrfObject* owner,
      DtSimManager* simManager, 
      DtComponentDescriptor* desc = 0,
      DtReaderWriterRegistry* parentRegistry = 0);

   virtual ~DtEmbarkationController();

   virtual bool init();

   virtual const char* type() const;

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

protected:
   virtual void registerTaskMsgCallbacks();

   virtual void unregisterTaskMsgCallbacks();

   virtual void preFirstTickInit();

   virtual void tick();

   virtual void clearCurrentTaskMessage();

   virtual void suspendTask();

   virtual void clearTask();

protected:
   virtual void processDisembarkTask(DtSimMessage* msg);
   static void disembarkTaskCallback(DtSimMessage* msg, void* usr);

   virtual void checkAndSetEgressPosture();

   virtual void processEmbarkTask(DtSimMessage* msg);
   static void embarkTaskCallback(DtSimMessage* msg, void* usr);

   static void embarkObjectCallback(DtSimMessage* msg, void* usr);
   virtual void processEmbarkObjectCallback(DtSimMessage* msg);

   static void disembarkObjectCallback(DtSimMessage* msg, void* usr);
   virtual void processDisembarkObjectCallback(DtSimMessage* msg);

   static void embarkationInformationCallback(DtSimMessage* msg, void* usr);
   virtual void processEmbarkationInformationCallback(DtSimMessage* msg);

protected:
   virtual void processLoadEntity(DtSimMessage * msg);
   virtual void processUnloadEntity(DtSimMessage * msg);

   static void setLoadEntityCallback(DtSimMessage * msg, void * usrData);
   static void setUnloadEntityCallback(DtSimMessage * msg, void * usrData);

   virtual void unload(const DtVector& point);

   static void deleteVrfObjectCallback(DtVrfObject * msg, void * usr);
   virtual void processDeleteVrfObjectCallback(DtVrfObject* obj);

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

protected:

   virtual void moveToEgress();

   virtual void movingToEgress();

   virtual void disembark();

   virtual void sendTask(const DtSimTask& task, const DtUUID& to);

   virtual void removeControlPoint();

   virtual void moveToIngress(const DtUUID& parent);

   virtual void createControlPoint(const DtVector& location,
      const DtUUID& parent);

   virtual void createRoute(const std::vector<DtVector>&, 
      const DtUUID& parent);

   virtual void moveToEmbarkationPoint();

   virtual void atEmbarkationPoint();

   virtual void waitingToStop();

   virtual void movingToIngress();

   virtual void embarkObject(bool overridePosition, 
      const DtVector& loadPosition, 
      const DtUUID& parent, int appearance = 0xFFFFFFFF, 
      const DtTaitBryan& orientation = DtTaitBryan(),
      const DtVector& acceleration = DtVector(), 
      const DtVector& velocty = DtVector(),
      bool invisibleWhenEmbarked = false);
   
   virtual void unloadObject(const DtVector& unloadPoint);

   virtual void embark(const DtVector& loadPosition, const DtUUID& parent, 
      int appearance = 0xFFFFFFFF, const DtTaitBryan& orientation = DtTaitBryan(),
      const DtVector& acceleration = DtVector(), 
      const DtVector& velocty = DtVector(),
      bool invisibleWhenEmbarked = false);

   virtual void movingToEmbarkationPoint();

   virtual void stoppedAtEmbarkedPoint();

   virtual void setState(DtVrfEmbarkationPSR::DtEmbarkationControllerState);
   virtual DtVrfEmbarkationPSR::DtEmbarkationControllerState state() const;

   virtual bool createPSR();

   virtual void setupExistingConditions();

   virtual void completeEmbarkationInformationRequest(
      const DtIfEmbarkationInformation*);

   virtual void embarkationRefused(const DtIfEmbarkationInformation*);

   virtual void completeDisembarkationInformationRequest(
      const DtIfEmbarkationInformation*);

   virtual void disembarkationRefused(const DtIfEmbarkationInformation*);

   virtual DtTaitBryan embarkedOrientation(const DtTaitBryan&, 
      const DtUUID& parent) const;

   virtual void moveToIngressPoint(const DtIfEmbarkationInformation* info);

   virtual void moveAlongToIngressPoint(const DtIfEmbarkationInformation* info);

   virtual void moveToEgressPoint(const DtIfEmbarkationInformation* info);

   virtual void moveAlongToEgressPoint(const DtIfEmbarkationInformation* info);

   virtual void issueMoveToEgressTask();
   virtual void issueMoveToIngressTask();

   virtual void issueMoveAlongToEgressTask();
   virtual void issueMoveAlongToIngressTask();

   virtual void issueMoveToEmbarkationPointTask();

   virtual DtVector currentBodyPosition(const DtUUID& parent) const;
   virtual DtTaitBryan currentBodyOrientation(const DtUUID& parent) const;
   virtual DtVector currentBodyVelocity(const DtUUID& parent) const;
   virtual DtVector currentBodyAcceleration(const DtUUID& parent) const;

protected:
   virtual bool requestEmbarkationInformationFrom(const DtUUID& parent,
      bool start = false, int embarkInSlot = -1, bool anyIfTaken = true);
   virtual bool requestDisembarkationInformationFrom(const DtUUID& parent,
      bool start = false);

   virtual void requestGiveUpSlot(const DtUUID& parent);

   virtual void waitingForEmbarkationInformation();
   virtual void waitingForDisembarkationInformation();

   virtual void placeObject(bool clamp = false);

   virtual void setLocation(const DtVector&);

   virtual void calculateAndSetHeading(const DtVector& start, const DtVector& end);

   virtual void sendSetRequest(DtSetDataRequest& request);

   virtual void processDisembarkationState(const DtVector& bodyExitPosition);
   virtual void movingToFinalDestination();
   virtual void moveToFinalDestination();

   virtual void preprocessEmbarkTask();
   virtual void preprocessDisembarkTask();

   virtual bool checkEmbarkOk(const DtUUID& parent) const;

   virtual void updateDisembarkedAppearance();

   virtual void updateEmbarkedAppearance(int);
   virtual void updateLifeformEmbarkedAppearance(int);

   virtual void attachToEmbarkedParent(const DtUUID& newParent);

   virtual DtVector fallbackOffloadPoint();

   virtual void enable();

   virtual void disable();

   virtual bool parentOnGround();

   static void setHeadingCallback(DtSimMessage*, void* usr);
   virtual void processSetHeading();

private:
   
   DtEmbarkationController();

   DtEmbarkationController(const DtEmbarkationController & 
      orig);

   const DtEmbarkationController & operator=(const 
      DtEmbarkationController & orig);

protected:
   std::list<DtString>  myEmbarkedObjects;

   DtVrfObject*   myControlPoint;

   DtVrfEmbarkationPSR* myProcessState;

   bool myWaiting;

   DtEmbarkationDescriptor*  myEmbarkationDescriptor;

   double myRequestTime;
   int    myRequestRetries;
   bool myAreCallbacksRegistered;

   bool myUseLoadOverrideIfNoSlotAvailable;
   DtVector myLoadOverridePosition;
   DtUUID myParentToLoadOn;

   bool myResetGroundClampOnDisembark;
   bool myResetGroundClampOnDisembarkValue;
   bool myRemoveSetHeadingNotifyCallback;

   bool myClampOnReceiveEmbarkationInformation;
};