managedInterface/messages/entityState.h

Go to the documentation of this file.

/*********************************************************************************
** Copyright (c) 1992-2025 MAK Technologies, Inc.
** All rights reserved.
*********************************************************************************/

#pragma once

#include "managedInterface/message.h"

#include <string>
#include <vlpi/entityType.h>
#include <matrix/vlVector.h>
#include <matrix/vlTaitBryan.h>
#include <vector>


class MANAGEDINTERFACE_DLL EntityStateMessage : public DtMessage
{
public:
   enum DeadReckoningAlgorithm {DeadReckoningAlgorithm_OTHER, DeadReckoningAlgorithm_STATIC, DeadReckoningAlgorithm_FPW, DeadReckoningAlgorithm_RPW, DeadReckoningAlgorithm_RVW, DeadReckoningAlgorithm_FVW, DeadReckoningAlgorithm_FPB, DeadReckoningAlgorithm_RPB, DeadReckoningAlgorithm_RVB, DeadReckoningAlgorithm_FVB};
   enum ConstituentPartStationName {ConstituentPartStationName_OTHER=0, ConstituentPartStationName_AIRCRAFT_WINGSTATION=1, ConstituentPartStationName_SHIPS_FORWARD_GUNMOUNT_STARBOARD=2, ConstituentPartStationName_SHIPS_FORWARD_GUNMOUNT_PORT=3, ConstituentPartStationName_SHIPS_FORWARD_GUNMOUNT_CENTERLINE=4, ConstituentPartStationName_SHIPS_AFT_GUNMOUNT_STARBOARD=5, ConstituentPartStationName_SHIPS_AFT_GUNMOUNT_PORT=6, ConstituentPartStationName_SHIPS_AFT_GUNMOUNT_CENTERLINE=7, ConstituentPartStationName_FORWARD_TORPEDO_TUBE=8, ConstituentPartStationName_AFT_TORPEDO_TUBE=9, ConstituentPartStationName_BOMB_BAY=10, ConstituentPartStationName_CARGO_BAY=11, ConstituentPartStationName_TRUCK_BED=12, ConstituentPartStationName_TRAILER_BED=13, ConstituentPartStationName_WELL_DECk=14, ConstituentPartStationName_ON_STATION_RNG_BRG=15, ConstituentPartStationName_ON_STATION_XYZ=16};
   enum TrailingEffects {TrailingEffects_NONE, TrailingEffects_SMALL, TrailingEffects_MEDIUM, TrailingEffects_LARGE};
   enum ForceType {ForceType_OTHER, ForceType_FRIENDLY, ForceType_OPPOSING, ForceType_NEUTRAL};
   enum LightType {LightType_LIGHTS=12, LightType_HEAD_LIGHTS=12, LightType_FLASH_LIGHTS=12, LightType_LANDING_LIGHTS=12, LightType_RUNNING_LIGHTS=12, LightType_TAIL_LIGHTS=13, LightType_NAVIGATION_LIGHTS=13, LightType_ANTI_COLLISION_LIGHTS=14, LightType_BRAKE_LIGHTS=14, LightType_FORMATION_LIGHTS=24, LightType_BLACK_OUT_LIGHTS=26, LightType_BLACK_OUT_BRAKE_LIGHTS=27, LightType_SPOT_LIGHTS=28, LightType_EXTERIOR_LIGHTS=28, LightType_EXTERNAL_LIGHTS=28, LightType_INTERIOR_LIGHTS=29, LightType_INTERNAL_LIGHTS=29};
   enum ParameterTypes {ParameterTypes_POSITION= 1, ParameterTypes_POSITIONRATE= 2, ParameterTypes_EXTENSION= 3, ParameterTypes_EXTENSIONRATE = 4, ParameterTypes_X= 5, ParameterTypes_XRATE= 6, ParameterTypes_Y= 7, ParameterTypes_YRATE= 8, ParameterTypes_Z= 9, ParameterTypes_ZRATE= 10, ParameterTypes_AZIMUTH= 11, ParameterTypes_AZIMUTHRATE= 12, ParameterTypes_ELEVATION= 13, ParameterTypes_ELEVATIONRATE = 14, ParameterTypes_ROTATION= 15, ParameterTypes_ROTATIONRATE= 16};
   enum WeaponState {WeaponState_NOWEAPON, WeaponState_STOWED, WeaponState_DEPLOYED, WeaponState_FIREPOSITION};
   enum ConstituentPartNature {ConstituentPartNature_OTHER=0, ConstituentPartNature_HOST_FIREABLE_MUNITION=1, ConstituentPartNature_MUNITION_CARRIED_AS_CARGO=2, ConstituentPartNature_FUEL_CARRIED_AS_CARGO=3, ConstituentPartNature_GUNMOUNT_ATTACHED_TO_HOST=4, ConstituentPartNature_COMPUTER_GENERATED_FORCES_CARRIED_AS_CARGO=5, ConstituentPartNature_VEHICLE_CARRIED_AS_CARGO=6, ConstituentPartNature_EMITTER_MOUNTED_ON_HOST=7, ConstituentPartNature_MOBILE_COMMAND_AND_CONTROL_ENTITY_CARRIED_ABOARD_HOST=8, ConstituentPartNature_ENTITY_STATIONED_AT=9, ConstituentPartNature_TEAM_MEMBER_IN_FORMATION_WITH=10};
   enum ComplianceState {ComplianceState_NA, ComplianceState_DETAINED, ComplianceState_SURRENDER, ComplianceState_USING_FISTS, ComplianceState_VERBAL_ABUSE1, ComplianceState_VERBAL_ABUSE2, ComplianceState_VERBAL_ABUSE3, ComplianceState_PASSIVE_RESISTANCE1, ComplianceState_PASSIVE_RESISTANCE2, ComplianceState_PASSIVE_RESISTANCE3, ComplianceState_NON_LETHAL_WEAPON1, ComplianceState_NON_LETHAL_WEAPON2, ComplianceState_NON_LETHAL_WEAPON3, ComplianceState_NON_LETHAL_WEAPON4, ComplianceState_NON_LETHAL_WEAPON5, ComplianceState_NON_LETHAL_WEAPON6};
   enum ConstituentPartPosition {ConstituentPartPosition_OTHER=0, ConstituentPartPosition_ON_TOP_OF=1, ConstituentPartPosition_INSIDE=2};
   enum DamageState {DamageState_NONE, DamageState_SLIGHT, DamageState_MODERATE, DamageState_DESTROYED};
   enum LifeformState {LifeformState_NA, LifeformState_STANDING, LifeformState_WALKING, LifeformState_RUNNING, LifeformState_KNEELING, LifeformState_PRONE, LifeformState_CRAWLING, LifeformState_SWIMMING, LifeformState_PARACHUTING, LifeformState_JUMPING, LifeformState_SITTING, LifeformState_SQUATTING, LifeformState_CROUCHING, LifeformState_WADING, LifeformState_SURRENDERED, LifeformState_DETAINED};
   enum HatchState {HatchState_NA, HatchState_CLOSED, HatchState_POPPED, HatchState_POPPEDANDPERSON, HatchState_OPEN, HatchState_OPENANDPERSON};
   enum CamoflageType {CamoflageType_DESERT, CamoflageType_WINTER, CamoflageType_FOREST};


   struct Parameter
   {
   float myValue;
   ParameterTypes myParameter;

        
      int size()
      {
         int size=0;
   size+=sizeof(float);
   size+=sizeof(int);

         return size;
      }

      void serialize(DtStreamWriter& writer)
      {
   writer.writeSingle(myValue);
   writer.writeInt32((int)myParameter);

      }
        
      void deserialize(DtStreamReader& reader)
      {
   myValue=reader.readSingle();
   myParameter=(ParameterTypes)reader.readInt32();

      }
   };


   struct ArtPart
   {
   int myId;
   int myAttachedTo;
   std::vector<Parameter> myParameters;

        
      int size()
      {
         int size=0;
   size+=sizeof(int);
   size+=sizeof(int);
         size+=4; //for the count of the items in the list
   for(unsigned int i=0; i<myParameters.size(); i++)
   {
      size+=myParameters[i].size();
   }


         return size;
      }

      void serialize(DtStreamWriter& writer)
      {
   writer.writeInt32(myId);
   writer.writeInt32(myAttachedTo);
   writer.writeInt32(myParameters.size()); //for the count of the items in the list
   for(unsigned int i=0; i<myParameters.size(); i++)
   {
      myParameters[i].serialize(writer);
   }


      }
        
      void deserialize(DtStreamReader& reader)
      {
   myId=reader.readInt32();
   myAttachedTo=reader.readInt32();
   unsigned int myParameters_count=reader.readInt32(); //for the count of the items in the list
   for(unsigned int i=0; i<myParameters_count; i++)
   {
      Parameter aParameter;
      aParameter.deserialize(reader);
      myParameters.push_back(aParameter);
   }

      }
   };


   struct AttPart
   {
   DtEntityType myType;
   int myStationId;

        
      int size()
      {
         int size=0;
      size+=8;
   size+=sizeof(int);

         return size;
      }

      void serialize(DtStreamWriter& writer)
      {
   writer.writeInt8(myType.kind());
   writer.writeInt8(myType.domain());
   writer.writeInt16(myType.country());
   writer.writeInt8(myType.category());
   writer.writeInt8(myType.subCategory());
   writer.writeInt8(myType.specific());
   writer.writeInt8(myType.extra());
   
   writer.writeInt32(myStationId);

      }
        
      void deserialize(DtStreamReader& reader)
      {
   myType.setKind(reader.readInt8());
   myType.setDomain(reader.readInt8());
   myType.setCountry(reader.readInt16());
   myType.setCategory(reader.readInt8());
   myType.setSubCategory(reader.readInt8());
   myType.setSpecific(reader.readInt8());
   myType.setExtra(reader.readInt8());
   
   myStationId=reader.readInt32();

      }
   };


   struct PStruct
   {
   float myPowerSetting;
   float myEngineRMP;

        
      int size()
      {
         int size=0;
   size+=sizeof(float);
   size+=sizeof(float);

         return size;
      }

      void serialize(DtStreamWriter& writer)
      {
   writer.writeSingle(myPowerSetting);
   writer.writeSingle(myEngineRMP);

      }
        
      void deserialize(DtStreamReader& reader)
      {
   myPowerSetting=reader.readSingle();
   myEngineRMP=reader.readSingle();

      }
   };


   struct VNStruct
   {
   float myHorizontalDeflectionAngle;
   float myVerticalDeflectionAngle;

        
      int size()
      {
         int size=0;
   size+=sizeof(float);
   size+=sizeof(float);

         return size;
      }

      void serialize(DtStreamWriter& writer)
      {
   writer.writeSingle(myHorizontalDeflectionAngle);
   writer.writeSingle(myVerticalDeflectionAngle);

      }
        
      void deserialize(DtStreamReader& reader)
      {
   myHorizontalDeflectionAngle=reader.readSingle();
   myVerticalDeflectionAngle=reader.readSingle();

      }
   };




  EntityStateMessage();
  virtual ~EntityStateMessage();

   virtual std::string getId();
   virtual void setId(std::string val);

   virtual std::string getEntityIdentifier();
   virtual void setEntityIdentifier(std::string val);

   virtual DtEntityType getType();
   virtual void setType(DtEntityType val);

   virtual DtEntityType getGuise();
   virtual void setGuise(DtEntityType val);

   virtual double getLastSetTime();
   virtual void setLastSetTime(double val);

   virtual DtVector getWorldPosition();
   virtual void setWorldPosition(DtVector val);

   virtual DtVector32 getWorldVelocity();
   virtual void setWorldVelocity(DtVector32 val);

   virtual DtVector32 getWorldAcceleration();
   virtual void setWorldAcceleration(DtVector32 val);

   virtual DtTaitBryan getWorldOrientation();
   virtual void setWorldOrientation(DtTaitBryan val);

   virtual DtVector32 getRotationalVelocity();
   virtual void setRotationalVelocity(DtVector32 val);

   virtual DeadReckoningAlgorithm getDeadReckoningType();
   virtual void setDeadReckoningType(DeadReckoningAlgorithm val);

   virtual bool getFrozenBit();
   virtual void setFrozenBit(bool val);

   virtual ForceType getForceType();
   virtual void setForceType(ForceType val);

   virtual std::string getMarkingText();
   virtual void setMarkingText(std::string val);

   virtual unsigned int getAppearanceBits();
   virtual void setAppearanceBits(unsigned int val);

   virtual unsigned int getCapabilityBits();
   virtual void setCapabilityBits(unsigned int val);

   virtual LifeformState getLifeformState();
   virtual void setLifeformState(LifeformState val);

   virtual std::vector<ArtPart> getArticulatedParts();
   virtual void setArticulatedParts(std::vector<ArtPart> val);

   virtual std::vector<AttPart> getAttachedParts();
   virtual void setAttachedParts(std::vector<AttPart> val);

   virtual unsigned short getInfraredSignatureIndex();
   virtual void setInfraredSignatureIndex(unsigned short val);

   virtual unsigned short getAcousticSignatureIndex();
   virtual void setAcousticSignatureIndex(unsigned short val);

   virtual unsigned short getLiveEntityMeasuredSpeed();
   virtual void setLiveEntityMeasuredSpeed(unsigned short val);

   virtual std::string getHostGlobalId();
   virtual void setHostGlobalId(std::string val);

   virtual ConstituentPartNature getPartNature();
   virtual void setPartNature(ConstituentPartNature val);

   virtual ConstituentPartPosition getPartPosition();
   virtual void setPartPosition(ConstituentPartPosition val);

   virtual ConstituentPartStationName getStationName();
   virtual void setStationName(ConstituentPartStationName val);

   virtual unsigned short getStationNumber();
   virtual void setStationNumber(unsigned short val);

   virtual DtVector32 getRelativePosition();
   virtual void setRelativePosition(DtVector32 val);

   virtual float getRange();
   virtual void setRange(float val);

   virtual float getBearing();
   virtual void setBearing(float val);

   virtual std::vector<PStruct> getPropulsionSystemsData();
   virtual void setPropulsionSystemsData(std::vector<PStruct> val);

   virtual std::vector<VNStruct> getVectoringNozzleSystemsData();
   virtual void setVectoringNozzleSystemsData(std::vector<VNStruct> val);



  virtual int messageSize();
  
   static DtMessage* decode(unsigned char* buffer, int length);
   static std::string theMessageName();

protected:
   static std::string theFullName;

   std::string myId;
   std::string myEntityIdentifier;
   DtEntityType myType;
   DtEntityType myGuise;
   double myLastSetTime;
   DtVector myWorldPosition;
   DtVector32 myWorldVelocity;
   DtVector32 myWorldAcceleration;
   DtTaitBryan myWorldOrientation;
   DtVector32 myRotationalVelocity;
   DeadReckoningAlgorithm myDeadReckoningType;
   bool myFrozenBit;
   ForceType myForceType;
   std::string myMarkingText;
   unsigned int myAppearanceBits;
   unsigned int myCapabilityBits;
   LifeformState myLifeformState;
   std::vector<ArtPart> myArticulatedParts;
   std::vector<AttPart> myAttachedParts;
   unsigned short myInfraredSignatureIndex;
   unsigned short myAcousticSignatureIndex;
   unsigned short myLiveEntityMeasuredSpeed;
   std::string myHostGlobalId;
   ConstituentPartNature myPartNature;
   ConstituentPartPosition myPartPosition;
   ConstituentPartStationName myStationName;
   unsigned short myStationNumber;
   DtVector32 myRelativePosition;
   float myRange;
   float myBearing;
   std::vector<PStruct> myPropulsionSystemsData;
   std::vector<VNStruct> myVectoringNozzleSystemsData;

   virtual void serialize(DtStreamWriter& writer);
   virtual void deserialize(DtStreamReader& reader);
};