localObject.h

Go to the documentation of this file.

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

#pragma once

#include "vrfobjcore/vrfobjcoreDefines.h"
#include "vrfcore/simulationServices.h"
#include "vrfobjcore/simObject.h"
#include "vrfobjcore/appearanceLocalObjectFacade.h"
#include "vrfobjcore/movementLocalObjectFacade.h"
#include "vrfStateData/stateComponent.h"
#include "vrfStateData/radioTransmitterStateComponent.h"
#include "vrfutil/vrfCallbackQueue.h"
#include "vrfStateData/stateData.h"
#include <readerWriter/noArgumentCallbackList.h>
#include "vrfobjcore/luaScriptInterfaceExtension.h"
#include <vrfutil/echelonId.h>
#include <vrfutil/vrf4XAPI.h>

namespace makVrf
{
   class DtExternalCurrentFrameState;
   class DtExternalNextFrameState;
   class DtLaserDesignatorStateComponent;
   class DtIffStateComponent;
   class DtActiveSonarStateComponent;
   class DtTaskVisualizationStateComponent;
   class DtNavAidRadioTransmitterStateComponent;
   class DtUnderwaterAcousticsStateComponent;
   class DtEmitterSystemStateComponent;
   class DtRadioReceiverStateComponent;
   class DtFrameStateInterface;
   class DtStatePropertiesStateComponent;
}

class DtPlan;
class DtVrfLocalObjectCreateInformation;
class DtSettingsObject;
class DtRadioDescriptorList;
class DtIfModifyVrfObject;
class DtVrfObjectStateRepository;
class DtVrfObjectSubComponentTypes;
class DtVrfObjectCommunicationInterface;
class DtVrfObjectTerrainPreloadManager;
class DtAttachedTerrain;
class DtVrfObjectPlanManager;
class DtSimTaskManager;
class DtSimResourceManager;
class DtSimRadio;
class DtScriptInterfaceHandler;
class DtSimComponentManager;
class DtSetDataManager;
class DtSimObjectStateRepository;
class DtVrfObjectMessage;
class DtLocalObjectDecorator;
class DtVrfObjectSubComponentTypes;

typedef DtLocalObject* (*DtLocalObjectCreatorFcn)(DtSimulationServices*, const DtVrfLocalObjectCreateInformation&);

struct DtVrfObjectHandoffData
{
   enum HandoffFlag
   {
      Prepare,
      BeforeConvertToRemote,
      AfterConvertToRemote,
      BeforeConvertToLocal,
      AfterConvertToLocal,
      Abort,
      Failed
   };

   HandoffFlag handoffFlag;
};

class DT_DLL_vrfobjcore DtLocalObject : public DtSimObject
{
protected:
   DtLocalObject(DtSimulationServices* simulationServices, const DtVrfLocalObjectCreateInformation& createInfo);
   
   DtLocalObject(DtSimulationServices* simulationServices);

public:
   enum ChangeFlag
   {
      ObjectName = 1,
      ForceType,
      ObjectLabel,
      OverlayParent,
      ObjectType,
      SubordinateOfForceLevel
   };

   virtual ~DtLocalObject() override;

   const makVrf::DtExternalNextFrameState* nextFrameState() const;
   makVrf::DtExternalNextFrameState* nextFrameState();

   template <typename T_Component>
   T_Component* getNextFrameStateComponent()
   {
      return nextFrameState()->getStateComponent<T_Component>();
   }

   template <typename T_Component>
   const T_Component* getNextFrameStateComponent() const
   {
      return nextFrameState()->getStateComponent<T_Component>();
   }

   

   virtual void setNextFrameParameterProperties(const DtRwProperties&);
   const DtRwProperties& nextFrameParameterProperties() const;

   virtual DtRwProperties& nextFrameStateProperties();
   virtual const DtRwProperties& nextFrameStateProperties() const;

   virtual const DtRwProperties& stateProperties() const;

   virtual DtPropertyInterface* stateProperty(const DtString& propertyName);
   virtual DtPropertyInterface* stateProperty(const DtString& context,
      const DtString& propertyName);
   virtual const DtPropertyInterface* stateProperty(const DtString& propertyName) const;
   virtual const DtPropertyInterface* stateProperty(const DtString& context,
      const DtString& propertyName) const;
   
   virtual DtPropertyInterface* addStateProperty(const DtString& context,
      const DtString& propertyName, int initialValue);
   virtual DtPropertyInterface* addStateProperty(const DtString& context,
      const DtString& propertyName, double initialValue);
   virtual DtPropertyInterface* addStateProperty(const DtString& context,
      const DtString& propertyName, bool initialValue);
   virtual DtPropertyInterface* addStateProperty(const DtString& context,
      const DtString& propertyName, const DtString& initialValue);
   virtual DtPropertyInterface* addStateProperty(const DtString& context,
      const DtString& propertyName, const DtVector& initialValue);
   
   virtual bool addStateProperty(const DtString& context,
      const DtString& propertyName, DtPropertyInterface* property);
      
   virtual void setNextFrameActivity(const DtString&);

   virtual void setGlobalIdentifierForPublication(const DtString&);

   virtual void setNextFrameExtendedData(const DtString& key, const DtString& value);
   virtual void setNextFrameExtendedDataMap(const std::map<DtString, DtString>&);
   virtual void setNextFrameExtendedDataMap(const std::map<std::string, std::string>&);
   virtual void clearNextFrameExtendedData();
   virtual void appendNextFrameExtendedData(const std::map<DtString, DtString>& s);
   virtual void setNextFrameExtendedLabel(int, const DtString& value);
   virtual void clearNextFrameExtendedLabels();
   virtual void setNextFrameExtendedLabels(const std::map<int, DtString>&);
   virtual DtAppearance nextFrameAppearance() const;

   virtual void setNextFrameLocalPosition(const DtVector& v);
   virtual DtString nextFrameLabel() const;

   virtual const DtVector& nextFrameLocalPosition() const;

   virtual void setNextFrameWorldPosition(const DtVector& v);
      virtual const DtVector& nextFrameWorldPosition() const;

   virtual void setNextFrameParentPosition(const DtVector& v);
   virtual const DtVector& nextFrameParentPosition() const;

   virtual void setNextFrameLocalOrientationMatrix(const DtDcm& v);
   virtual const DtDcm& nextFrameLocalOrientationMatrix() const;

   virtual void setNextFrameLocalOrientationWrtDatabase(const DtTaitBryan& v);
   virtual const DtTaitBryan& nextFrameLocalOrientationWrtDatabase() const;

   virtual void setNextFrameLocalOrientation(const DtTaitBryan& v);
   virtual const DtTaitBryan& nextFrameLocalOrientation() const;

   virtual const DtTaitBryan& nextFrameTopographicOrientation() const;

   virtual void setNextFrameParentOrientation(const DtTaitBryan& v);
   virtual const DtTaitBryan& nextFrameParentOrientation() const;

   virtual void setNextFrameWorldOrientation(const DtTaitBryan& v);
   virtual void setNextFrameWorldOrientationMatrix(const DtDcm& v);
   virtual const DtTaitBryan& nextFrameWorldOrientation() const;
   virtual const DtDcm& nextFrameWorldOrientationMatrix() const;

   virtual void setNextFrameLocalVertices(const DtList& vertices, DtVector& newGeometricCenter);
   virtual void setNextFrameLocalVertices(const DtLocalVertexList& vertices, DtVector& newGeometricCenter);
   virtual void removeNextFrameVertex(int iIndex);
   virtual void addNextFrameLocalVertex(const DtVector& vertex);
   virtual void addNextFrameLocalVertex(const DtVector& vertex, DtVector& newGeometricCenter);

   virtual void setNextFrameWorldVertices(const std::vector<DtVector>& vertices, DtVector& newGeometricCenter);
   virtual void setNextFrameWorldVertices(const DtVertexList& vertices, DtVector& newGeometricCenter);
   virtual void setNextFrameWorldVertices(const DtList& vertices, DtVector& newGeometricCenter);
   virtual void addNextFrameWorldVertex(const DtVector& vertex, DtVector& newGeometricCenter);

   bool nextFrameIsDestroyed() const;
   int nextFrameDamageState() const;

   virtual void setNextFrameRelativeVertices(const DtLocalVertexList& vertices);

   virtual const DtLocalVertexList& nextFrameLocalVertices() const;
   virtual const DtVertexList& nextFrameWorldVertices() const;
   virtual const DtLocalVertexList& nextFrameRelativeVertices() const;

   virtual double nextFrameHeading() const;
   virtual double nextFramePitch() const;
   virtual double nextFrameRoll() const;


   virtual void setNextFrameLabel(const DtString&);

   virtual const DtString& nextFrameExtendedData(const DtString&) const;


   virtual void setNextFrameIsSubordinateOfForceLevel(bool);
   virtual bool nextFrameIsSubordinateOfForceLevel() const;

   virtual bool nextFrameIsLocal() const;
   virtual bool isLocal() const override;

   virtual void removedFromSimulation();


   virtual void setNextFrameInvisible(bool);
   virtual bool nextFrameInvisible() const;

   virtual void setNextFrameOverlay(const DtString&);

   virtual bool nextFrameSensorsKilled() const;
   virtual void setNextFrameSensorsKilled(bool sensorsKilled);

   virtual void setNextFrameInvisibleSetByUser(bool b);
   virtual bool nextFrameInvisibleSetByUser() const;

   virtual DtString nextFrameOverlay() const;



   virtual DtOutputStream& objectConsoleDebug(const DtString& channel = "") const;

   virtual DtOutputStream& objectConsoleVerbose(const DtString& channel = "") const;

   virtual DtOutputStream& objectConsoleInfo(const DtString& channel = "") const;

   virtual DtOutputStream& objectConsoleWarn(const DtString& channel = "") const;

   virtual DtOutputStream& objectConsoleError(const DtString& channel = "") const;

   int notifyLevel() const;
   const DtObjectConsole* objectConsole() const;

   virtual void makeInvalid() override;

   bool isValid() const;

   bool publishObject() const;
   int publishFlag() const;
   virtual void setNextFrameIsClutterEntity(bool b);
   virtual bool nextFrameIsClutterEntity() const;
   virtual void setNextFrameIsVrfSimulated(bool);
   virtual bool nextFrameIsVrfSimulated() const;

   virtual void setNextFrameCallsign(const DtString& cs);
   virtual const DtString& nextFrameCallsign() const;

   virtual bool isRemoteAttachedObject() const;

   virtual void setNextFrameEngagementRules(const DtString&);
   virtual DtString nextFrameEngagementRules() const;

   virtual void setNextFrameIsTasked(bool);
   virtual bool nextFrameIsTasked() const;

   virtual void setNextFrameIndependentlyTasked(bool);
   virtual bool nextFrameIndependentlyTasked() const;

   virtual void setNextFrameGlobalId(const DtString&);

   virtual void setNextFrameEntityId(const DtEntityIdentifier& id);
   virtual DtEntityIdentifier nextFrameEntityId() const;

   virtual bool setNextFrameObjectName(const DtString&);
   virtual DtString nextFrameObjectName() const;

   virtual void setNextFrameObjectType(const DtEntityType&);
   virtual DtEntityType nextFrameObjectType() const;

   void setNotifyLevel(int);
   DtSimulationServices* simulationServices() const;

   bool convertingToLocal() const
   {
      return myConvertingToLocal;
   }

   virtual void setConvertingToRemote(bool);
   bool convertingToRemote() const
   {
      return myConvertingToRemote;
   }

   template <typename T_Component>
   T_Component* addStateComponent(bool checkWritable = false, bool isRemote = false)
   {
      if (isValid())
      {
         T_Component* comp = myExternalNextFrameState->addStateComponent<T_Component>(checkWritable, isRemote);

         if (comp)
         {
            makVrf::DtStateData* sd = const_cast<DtSimulationServices*>(mySimulationServices)->stateDataManager()->stateDataFor(myUUID);

            if (sd)
            {
               makVrf::DtStateComponent* stateComponent = sd->getStateComponent<T_Component>(comp->id());

               if (stateComponent)
               {
                  stateComponent->setIsRemoteComponent(false);
               }
            }
         }

         return comp;
      }
      else
      {
         throw makVrf::DtUnimplementedMethod("The addStateComponent is not implemented for this class.");
      }
   }

   makVrf::DtFrameStateInterface* addStateComponent(makVrf::DtStateComponent::StateComponentType t);

   virtual bool nextFrameIsEmbarked() const;
   virtual DtUUID nextFrameEmbarkedOn() const;
   virtual void setNextFrameEmbarkedOn(const DtUUID& u);
   virtual bool nextFrameIsEmbarkedOn(const DtUUID&) const;
   virtual DtSimObjectReference nextFrameSimObjectEmbarkedOn() const;

   virtual void setNextFrameEchelonId(const DtEchelonId&);
   virtual DtEchelonId nextFrameEchelonId() const;

   virtual void setNextFrameForceType(int);
   virtual DtForceType nextFrameForceType() const;

   virtual void setNextFrameSessionId(int);
   virtual int nextFrameSessionId() const;

   virtual void setNextFrameVrfMessageVersionSupported(int);
   virtual int nextFrameVrfMessageVersionSupported() const;

   virtual void removeNextFrameExtendedData(const DtString&);

   void removeStateComponent(const makVrf::DtFrameStateInterface*);

   virtual void upgradeFromImport();

   makVrf::DtTaskVisualizationStateComponent* lineTaskVisualization(const DtString& visualName, const DtString& component);
   makVrf::DtTaskVisualizationStateComponent* pointTaskVisualization(const DtString& visualName, const DtString& component);
   makVrf::DtTaskVisualizationStateComponent* areaTaskVisualization(const DtString& visualName, const DtString& component);
   makVrf::DtTaskVisualizationStateComponent* textTaskVisualization(const DtString& visualName, const DtString& component);
   void removeTaskVisualization(makVrf::DtTaskVisualizationStateComponent*);

   makVrf::DtLaserDesignatorStateComponent* addLaserDesignator();
   void removeLaserDesignator(makVrf::DtLaserDesignatorStateComponent*);

   makVrf::DtEmitterSystemStateComponent* addEmitterSystem();
   void removeEmitterSystem(makVrf::DtEmitterSystemStateComponent*);

   makVrf::DtActiveSonarStateComponent* addActiveSonarSystem();
   void removeActiveSonarSystem(makVrf::DtActiveSonarStateComponent*);

   makVrf::DtRadioTransmitterStateComponent* addRadioTransmitter();
   void removeRadioTransmitter(makVrf::DtRadioTransmitterStateComponent*);

   makVrf::DtNavAidRadioTransmitterStateComponent* addNavAidRadioTransmitter();
   void removeNavAidRadioTransmitter(makVrf::DtNavAidRadioTransmitterStateComponent*);

   makVrf::DtRadioReceiverStateComponent* addRadioReceiver();
   void removeRadioReceiver(makVrf::DtRadioReceiverStateComponent*);

   makVrf::DtIffStateComponent* getOrCreateIffSystem();
   void removeIffSystem();

   makVrf::DtUnderwaterAcousticsStateComponent* getOrCreateUnderwaterAcousticsSystem(bool isRemote = false);
   void removeUnderwaterAcousticsSystem();

   virtual void setNextFrameUnderFire(bool b);
   virtual bool nextFrameUnderFire() const;
   virtual void setNextFrameInvulnerable(bool);
   virtual bool nextFrameInvulnerable() const;

   virtual void setNextFrameUndetectable(bool);
   virtual bool nextFrameUndetectable() const;

   virtual void setNextFrameHalfLengthWidthHeight(double length, double width, double height);
   virtual void setNextFrameObjectGeometry(const makVrf::DtVrfObjectGeometry&);
   virtual void setNextFrameBoundingGeometryType(DtSimBoundingGeometry::DtSimBoundingGeometryType type);
   virtual void setNextFrameBoundingVolume(const Dt3dBoundingVolume& b);

   virtual void setNextFrameHasPlan(bool);
   virtual bool nextFrameHasPlan() const;

   virtual void setNextFrameExecutingPlan(bool);
   virtual bool nextFrameExecutingPlan() const;

   virtual void setNextFrameOccupantsHidden(int);
   virtual bool nextFrameOccupantsHidden() const;
   
   virtual std::map<DtString, DtString> nextFrameExtendedDataMap() const;

   virtual std::map<int, DtString> nextFrameExtendedLabels() const;

   virtual bool nextFrameIsOnTopOf(const DtSimObject* o, bool checkSupportPoints = false) const;
   virtual bool nextFrameIsOnTopOf(const DtSimObject* o, double d, bool checkSupportPoints = false) const;

   DtLocalObjectDecorator* getOrCreateDecorator(const std::string& Decorator);

   void setLocationComplete();

   boost::signals2::signal<void ()> signal_preObjectReinitialize;
   boost::signals2::signal<void (bool success)> signal_postObjectReinitialize;

   boost::signals2::signal<void ()> signal_resourceChangedBySet;

   boost::signals2::signal<void ()> signal_preUpgradeFromImport;

   boost::signals2::signal<void ()> signal_postUpgradeFromImport;

   boost::signals2::signal<void ()> signal_objectInitialized;

   boost::signals2::signal<void ()> signal_objectRestored;

   boost::signals2::signal <void (DtLocalObject*)> signal_objectModifiedViaMessage;

   boost::signals2::signal <void (DtLocalObject*)> signal_newSensorContact;

   boost::signals2::signal <void (DtLocalObject*)> signal_navigationAreaChanged;

   boost::signals2::signal <void (DtLocalObject*)> signal_setLocationComplete;

   boost::signals2::signal<void ()> signal_restored;

   mutable boost::signals2::signal<void (const DtLocalObject*, ChangeFlag)> signal_objectDataChanged;

   boost::signals2::signal<void(const DtLocalObject*)> signal_localObjectAboutToBeDeleted;
   
   virtual void setNextFrameStateProperties(const DtRwProperties&);

   virtual bool nextFrameFuelLevelsFrozen() const;

   virtual bool nextFrameMunitionLevelsFrozen() const;

   virtual void setSimulationCapable(bool);
   bool simulationCapable() const;

   virtual void setNextFrameBlockParachute(bool);
   virtual bool nextFrameBlockParachute() const;

   virtual void setNextFrameOnTerrainSurface(bool b);
   virtual bool nextFrameOnTerrainSurface() const;

   virtual void setOperationInProgress(int, bool);
   virtual bool operationInProgress(int) const;
   virtual void clearOperationsInProgress();

public:

   virtual bool createInternalState(const DtVrfObjectParameters* parameterEntry);

   virtual bool setupSubComponentTypes();

   virtual bool init();

   virtual bool create();

   static DtLocalObjectCreatorFcn setLocalObjectCreatorFunction(DtLocalObjectCreatorFcn);
   static DtLocalObjectCreatorFcn localObjectCreatorFunction();
   static DtLocalObject* create(DtSimulationServices*, const DtVrfLocalObjectCreateInformation&);

   static DtLocalObject* createAndInit(DtSimulationServices*, const DtVrfLocalObjectCreateInformation&);


   static void readDRThresholdSettingsCallback(
      const DtSettingsObject* settings, void* usr);
   virtual void processReadDRThresholdSettings(const DtSettingsObject* settings);

   bool isGlobalPlan() const;

   bool isSyncMatrix() const;

   virtual int publicationFlag() const;

   virtual bool isCapableOfTask(std::string taskName);

public:

   virtual bool convertToRemoteObject(DtString& error);
   virtual bool convertToLocalObject(DtString& error, const std::string& archiveState);
   boost::signals2::signal<void (DtLocalObject*, DtVrfObjectHandoffData::HandoffFlag)> signal_handoffStep;

   virtual bool prepareForHandoff();
   mutable boost::signals2::signal<void (DtLocalObject*, DtVrfObjectHandoffData&)> signal_prepareForHandoff;

   virtual std::string archiveState() const;

public:
   typedef std::list<DtLuaScriptInterfaceExtension::CreatorUserPair> ScriptInterfaceExtensions;

   const DtSimResourceManager& resourceManager() const;
   DtSimResourceManager& resourceManager();

   virtual DtVrfObjectStateRepository* internalState();
   virtual const DtVrfObjectStateRepository* internalState() const;

   enum ReinitializeFlags
   {
      ReinitializeDefault = 0x00000000,
      ReinitializeKeepPSR = 0x00000001,
      ReinitializeStateData = 0x00000002,
   };

   virtual void prepareForReinitialization(ReinitializeFlags flags = ReinitializeDefault);

   DtVrfObjectSubComponentTypes* vrfSubComponentTypes() const;

   virtual void tick();

protected:
   virtual void startTick();
   virtual void tickComponents();
   virtual void endTick();

public:

   virtual int scenarioRunId() const;

   virtual bool checkIfMoveOntoEmbarked(const DtVector& localPosition, const DtSimObject*& hit, const std::list<DtUUID>& additionalIgnore = std::list<DtUUID>());

   virtual bool checkAndDisembarkIfEmbarked(const DtVector& localPosition);
   virtual bool lowFidelityDisembarkHitCheck(const DtVector& localPosition) const;
   virtual bool highFidelityDisembarkHitCheck(const DtVector& localPosition) const;

   virtual int nextEmitterSystemId();
   
public:
   virtual DtVrfObjectCommunicationInterface* communicationInterface();
   virtual const DtVrfObjectCommunicationInterface* communicationInterface() const;
   virtual DtVrfObjectTerrainPreloadManager* terrainPreloadManager();
   virtual DtSimRadio* radio() const;
   virtual DtSimTaskManager* taskManager() const;
   virtual DtScriptInterfaceHandler* scriptInterfaceHandler() const;
   virtual DtVrfObjectPlanManager* vrfObjectPlanManager() const;
   virtual DtSimComponentManager* componentManager();
   virtual const DtSimComponentManager* componentManager() const;

   virtual DtSetDataManager* setDataManager();
   virtual const DtSetDataManager* setDataManager() const;

   bool initialized() const
   {
      return myInitialized;
   }

   DtVrfCallbackQueue::CallbackInterface::Ptr parallelContainer()
   {
      if (!myParallelContainer)
      {
         myParallelContainer = DtVrfCallbackQueue::CallbackInterface::Ptr(new SimObjectCallback(this));
      }

      return myParallelContainer;
   }

public:
   virtual void cleanupItemsNeededForHandoff();
   virtual bool recreateItemsNeededFromHandoff();

   virtual void cleanupItemsNeededForReinitialize();

   virtual bool reinitialize();

protected:
   static void logToFileCallback(const DtVrfObjectMessage* msg, void* usr);
   virtual void processLogToFile(const DtVrfObjectMessage* msg);

   static void stopLoggingToFileCallback(const DtVrfObjectMessage* msg, void* usr);
   virtual void processStopLoggingToFile(const DtVrfObjectMessage* msg);

   virtual void createNavigationDecorator() override;

   class SimObjectCallback : public DtVrfCallbackQueue::CallbackInterface
   {
   public:
      typedef std::vector<SimObjectCallback> Vector;

      DtLocalObject* object;

      explicit SimObjectCallback(DtLocalObject* obj)
         : object(obj)
      {
      }

      virtual void run() override;
   };

public:
   
   virtual void addScriptExtension(DtLuaScriptInterfaceExtension::CreatorFcn extension, void* usr);
   virtual void removeScriptExtension(DtLuaScriptInterfaceExtension::CreatorFcn extension, void* usr);
   virtual const ScriptInterfaceExtensions& scriptExtensions() const;

   virtual void setupFromMessageContent(const DtIfModifyVrfObject* ifModVrfObject);
   virtual bool validNameLength(const DtString& name) const;

   static bool shouldArchiveExtendedAttribute(const DtString& s);
   static void doNotArchiveAttribute(const DtString& s, bool b);
   
   virtual void sendVrfObjectCreated(unsigned long requestId = 0, bool requestCreated = true);

   virtual void setIsInMovementFlux(bool, const DtVector& proposedLocation = DtVector::zero());

   boost::signals2::signal<void (DtLocalObject*)> signal_postInitFromParams;

protected:
   virtual void setupStateRepository();
   virtual void internalStateInitializedFromParameters();

   virtual bool createCommunicationsInterface();
   virtual void initializeCommunicationInterfaceCallbacks();
   static void setOverlayLayerTaskCallback(const DtVrfObjectMessage* msg, void* usr);
   virtual void processSetOverlayLayerTask(const DtVrfObjectMessage* msg);

   virtual bool createScriptInterfaceHandler();

   virtual bool createComponentManager();

   virtual bool initializeComponentManager();

   virtual bool createRadio();
   virtual bool createVrfObjectPlanManager();
   virtual bool createSetDataManager();

   virtual void tickDecorators();

   void createRemotelyControlledLocalObject();
   virtual void completeSetup() override;

protected:
   virtual bool createTaskManager();

   virtual void createCommunicationsInterface(const DtRadioDescriptorList& descList);

   virtual void updateEntityHasTarget();

protected:
   virtual void setUUID(const DtUUID&) override;

   virtual void convertedToRemote();

   virtual std::map<DtString, DtString> unarchivedData();

   virtual void clearDecorators() override;

   virtual void usingParameterSource(const DtString&) override;

   virtual void setupVrfObjectParameters() override;

   void cacheNextFrameComponents();
   void clearNextFrameCachedComponents();

   virtual void hostChanged(const DtUUID& oldHost, const DtUUID& newHost) override;

   virtual void isClutterChanged() override;

   friend class DtVrfObjectStateRepository;
   virtual void setupExtendedDataFromParameterData();

   virtual bool canBePlaced() const;

protected:
   DtLocalObject(const DtLocalObject& orig);

   DtLocalObject& operator=(const DtLocalObject& orig);

protected:
   DtVrfObjectStateRepository*         myInternalState;
   DtVrfObjectSubComponentTypes*       mySubComponentTypes;
   makVrf::DtExternalNextFrameState*   myExternalNextFrameState;
   DtVrfObjectCommunicationInterface*  myCommunicationInterface;
   DtVrfObjectTerrainPreloadManager*   myTerrainPreloadManager;
   DtSimRadio*                         myRadio;
   DtSimTaskManager*                   myTaskManager;
   DtScriptInterfaceHandler*           myScriptInterfaceHandler;
   DtSimComponentManager*              myComponentManager;
   DtVrfObjectPlanManager*             myVrfObjectPlanManager;
   DtSetDataManager*                   mySetDataManager;

   bool myCreatedStateData;

   typedef std::map<std::string, DtLocalObjectDecorator*> LocalObjectDecorators;
   LocalObjectDecorators myLocalObjectDecorators;

   boost::signals2::scoped_connection myConvertedToRemoteConnection;
   static DtLocalObjectCreatorFcn theLocalObjectCreatorFunction;

   DtVrfLocalObjectCreateInformation* myLocalObjectCreateInformation;

   bool myInitializing;
   bool myInitialized;
   int myNextEmitterSystemId;
   static std::set<DtString> theDoNotArchiveAttributes;

   DtAppearanceLocalObjectFacade* myAppearanceLocalObjectFacade;

   ScriptInterfaceExtensions myScriptInterfaceExtensions;

   bool myConvertingToLocal;

   bool myConvertingToRemote;

   bool mySimulationCapable;

   bool myHasTarget;
   bool myControllersTicked;
   bool mySkipNextComponentTick;
   bool mySignalLocationComplete;
   bool myIsEnvironmental = false;

   mutable DtRwProperties* myDefaultStateProperties;

   makVrf::DtLocationStateComponent* myNextFrameLocationStateComponent;
   
   makVrf::DtSimulatedObjectStateComponent* myNextFrameSimulatedObjectStateComponent;
   
   makVrf::DtVrfGeometryStateComponent* myNextFrameVrfGeometryStateComponent;
   
   makVrf::DtVrfStateComponent* myNextFrameVrfStateComponent;
   
   makVrf::DtStatePropertiesStateComponent* myNextFrameStatePropertiesStateComponent;
   
   const makVrf::DtStatePropertiesStateComponent* myCurrentFrameStatePropertiesStateComponent;

   DtSimObjectReference myNextFrameSimObjectEmbarkedOn;

   DtMovementLocalObjectFacade* myMovementLocalObjectFacade;

   typedef std::map<int, int> OperationsInProgressCount;
   
   OperationsInProgressCount myOperationsInProgressCount;

   int myFluxIndex = -1;

   DtVrfCallbackQueue::CallbackInterface::Ptr myParallelContainer;

   DtPlan* myReinitializePlan = nullptr;

public:
   VRF4API_METHOD DtVrfObjectStateRepository* vrfState() { return internalState(); };
   VRF4API_METHOD const DtVrfObjectStateRepository* vrfState() const { return internalState(); };
   VRF4API_METHOD void setObjectIdentifier(const DtEntityIdentifier& id) { setNextFrameEntityId(id); };
   VRF4API_METHOD void place(const DtReal heading, bool* dataAvailable = 0,
      bool requireAllData = false);
      
   VRF4API_METHOD void place(const DtVector& heading, bool* dataAvailable = 0,
      bool requireAllData = false);
   VRF4API_METHOD bool isVrfSimulated() const { return nextFrameIsVrfSimulated(); };
   VRF4API_METHOD void invokeSetLocationCompleteCallbacks() { return setLocationComplete(); };
};