spacedatastandards.org 1.73.0__py3-none-any.whl

MSL/MSL.py

@@ -0,0 +1,642 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Guided Missiles
+class MSL(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = MSL()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsMSL(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def MSLBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x4D\x53\x4C", size_prefixed=size_prefixed)
+
+    # MSL
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # MSL
+    def POSITION_X(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # MSL
+    def POSITION_Y(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # MSL
+    def POSITION_Z(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # MSL
+    def VELOCITY_X(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # MSL
+    def VELOCITY_Y(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # MSL
+    def VELOCITY_Z(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # MSL
+    def ATTITUDE_X(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # MSL
+    def ATTITUDE_Y(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # MSL
+    def ATTITUDE_Z(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # MSL
+    def ATTITUDE_W(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # MSL
+    def OMEGA_X(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # MSL
+    def OMEGA_Y(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # MSL
+    def OMEGA_Z(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # MSL
+    def MASS(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # MSL
+    def MASS_INITIAL(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # MSL
+    def TARGET_POSITION_X(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # MSL
+    def TARGET_POSITION_Y(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # MSL
+    def TARGET_POSITION_Z(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(38))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # MSL
+    def TARGET_VELOCITY_X(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(40))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # MSL
+    def TARGET_VELOCITY_Y(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(42))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # MSL
+    def TARGET_VELOCITY_Z(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(44))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # MSL
+    def MISS_DISTANCE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(46))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # MSL
+    def SEEKER(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(48))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # MSL
+    def MOTOR(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(50))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # MSL
+    def GUIDANCE_CMD(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # MSL
+    def PHASE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(54))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # MSL
+    def GUIDANCE_LAW(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(56))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # MSL
+    def TYPE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(58))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # MSL
+    def ARMED(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(60))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # MSL
+    def TIME_OF_FLIGHT(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(62))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 0.0
+
+    # MSL
+    def MAX_G(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 0.0
+
+    # MSL
+    def RESERVED(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(66))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # MSL
+    def RESERVEDAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(66))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # MSL
+    def RESERVEDLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(66))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # MSL
+    def RESERVEDIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(66))
+        return o == 0
+
+def MSLStart(builder):
+    builder.StartObject(32)
+
+def Start(builder):
+    MSLStart(builder)
+
+def MSLAddPOSITION_X(builder, POSITION_X):
+    builder.PrependFloat64Slot(0, POSITION_X, 0.0)
+
+def AddPOSITION_X(builder, POSITION_X):
+    MSLAddPOSITION_X(builder, POSITION_X)
+
+def MSLAddPOSITION_Y(builder, POSITION_Y):
+    builder.PrependFloat64Slot(1, POSITION_Y, 0.0)
+
+def AddPOSITION_Y(builder, POSITION_Y):
+    MSLAddPOSITION_Y(builder, POSITION_Y)
+
+def MSLAddPOSITION_Z(builder, POSITION_Z):
+    builder.PrependFloat64Slot(2, POSITION_Z, 0.0)
+
+def AddPOSITION_Z(builder, POSITION_Z):
+    MSLAddPOSITION_Z(builder, POSITION_Z)
+
+def MSLAddVELOCITY_X(builder, VELOCITY_X):
+    builder.PrependFloat64Slot(3, VELOCITY_X, 0.0)
+
+def AddVELOCITY_X(builder, VELOCITY_X):
+    MSLAddVELOCITY_X(builder, VELOCITY_X)
+
+def MSLAddVELOCITY_Y(builder, VELOCITY_Y):
+    builder.PrependFloat64Slot(4, VELOCITY_Y, 0.0)
+
+def AddVELOCITY_Y(builder, VELOCITY_Y):
+    MSLAddVELOCITY_Y(builder, VELOCITY_Y)
+
+def MSLAddVELOCITY_Z(builder, VELOCITY_Z):
+    builder.PrependFloat64Slot(5, VELOCITY_Z, 0.0)
+
+def AddVELOCITY_Z(builder, VELOCITY_Z):
+    MSLAddVELOCITY_Z(builder, VELOCITY_Z)
+
+def MSLAddATTITUDE_X(builder, ATTITUDE_X):
+    builder.PrependFloat64Slot(6, ATTITUDE_X, 0.0)
+
+def AddATTITUDE_X(builder, ATTITUDE_X):
+    MSLAddATTITUDE_X(builder, ATTITUDE_X)
+
+def MSLAddATTITUDE_Y(builder, ATTITUDE_Y):
+    builder.PrependFloat64Slot(7, ATTITUDE_Y, 0.0)
+
+def AddATTITUDE_Y(builder, ATTITUDE_Y):
+    MSLAddATTITUDE_Y(builder, ATTITUDE_Y)
+
+def MSLAddATTITUDE_Z(builder, ATTITUDE_Z):
+    builder.PrependFloat64Slot(8, ATTITUDE_Z, 0.0)
+
+def AddATTITUDE_Z(builder, ATTITUDE_Z):
+    MSLAddATTITUDE_Z(builder, ATTITUDE_Z)
+
+def MSLAddATTITUDE_W(builder, ATTITUDE_W):
+    builder.PrependFloat64Slot(9, ATTITUDE_W, 0.0)
+
+def AddATTITUDE_W(builder, ATTITUDE_W):
+    MSLAddATTITUDE_W(builder, ATTITUDE_W)
+
+def MSLAddOMEGA_X(builder, OMEGA_X):
+    builder.PrependFloat64Slot(10, OMEGA_X, 0.0)
+
+def AddOMEGA_X(builder, OMEGA_X):
+    MSLAddOMEGA_X(builder, OMEGA_X)
+
+def MSLAddOMEGA_Y(builder, OMEGA_Y):
+    builder.PrependFloat64Slot(11, OMEGA_Y, 0.0)
+
+def AddOMEGA_Y(builder, OMEGA_Y):
+    MSLAddOMEGA_Y(builder, OMEGA_Y)
+
+def MSLAddOMEGA_Z(builder, OMEGA_Z):
+    builder.PrependFloat64Slot(12, OMEGA_Z, 0.0)
+
+def AddOMEGA_Z(builder, OMEGA_Z):
+    MSLAddOMEGA_Z(builder, OMEGA_Z)
+
+def MSLAddMASS(builder, MASS):
+    builder.PrependFloat64Slot(13, MASS, 0.0)
+
+def AddMASS(builder, MASS):
+    MSLAddMASS(builder, MASS)
+
+def MSLAddMASS_INITIAL(builder, MASS_INITIAL):
+    builder.PrependFloat64Slot(14, MASS_INITIAL, 0.0)
+
+def AddMASS_INITIAL(builder, MASS_INITIAL):
+    MSLAddMASS_INITIAL(builder, MASS_INITIAL)
+
+def MSLAddTARGET_POSITION_X(builder, TARGET_POSITION_X):
+    builder.PrependFloat64Slot(15, TARGET_POSITION_X, 0.0)
+
+def AddTARGET_POSITION_X(builder, TARGET_POSITION_X):
+    MSLAddTARGET_POSITION_X(builder, TARGET_POSITION_X)
+
+def MSLAddTARGET_POSITION_Y(builder, TARGET_POSITION_Y):
+    builder.PrependFloat64Slot(16, TARGET_POSITION_Y, 0.0)
+
+def AddTARGET_POSITION_Y(builder, TARGET_POSITION_Y):
+    MSLAddTARGET_POSITION_Y(builder, TARGET_POSITION_Y)
+
+def MSLAddTARGET_POSITION_Z(builder, TARGET_POSITION_Z):
+    builder.PrependFloat64Slot(17, TARGET_POSITION_Z, 0.0)
+
+def AddTARGET_POSITION_Z(builder, TARGET_POSITION_Z):
+    MSLAddTARGET_POSITION_Z(builder, TARGET_POSITION_Z)
+
+def MSLAddTARGET_VELOCITY_X(builder, TARGET_VELOCITY_X):
+    builder.PrependFloat64Slot(18, TARGET_VELOCITY_X, 0.0)
+
+def AddTARGET_VELOCITY_X(builder, TARGET_VELOCITY_X):
+    MSLAddTARGET_VELOCITY_X(builder, TARGET_VELOCITY_X)
+
+def MSLAddTARGET_VELOCITY_Y(builder, TARGET_VELOCITY_Y):
+    builder.PrependFloat64Slot(19, TARGET_VELOCITY_Y, 0.0)
+
+def AddTARGET_VELOCITY_Y(builder, TARGET_VELOCITY_Y):
+    MSLAddTARGET_VELOCITY_Y(builder, TARGET_VELOCITY_Y)
+
+def MSLAddTARGET_VELOCITY_Z(builder, TARGET_VELOCITY_Z):
+    builder.PrependFloat64Slot(20, TARGET_VELOCITY_Z, 0.0)
+
+def AddTARGET_VELOCITY_Z(builder, TARGET_VELOCITY_Z):
+    MSLAddTARGET_VELOCITY_Z(builder, TARGET_VELOCITY_Z)
+
+def MSLAddMISS_DISTANCE(builder, MISS_DISTANCE):
+    builder.PrependFloat64Slot(21, MISS_DISTANCE, 0.0)
+
+def AddMISS_DISTANCE(builder, MISS_DISTANCE):
+    MSLAddMISS_DISTANCE(builder, MISS_DISTANCE)
+
+def MSLAddSEEKER(builder, SEEKER):
+    builder.PrependUOffsetTRelativeSlot(22, flatbuffers.number_types.UOffsetTFlags.py_type(SEEKER), 0)
+
+def AddSEEKER(builder, SEEKER):
+    MSLAddSEEKER(builder, SEEKER)
+
+def MSLAddMOTOR(builder, MOTOR):
+    builder.PrependUOffsetTRelativeSlot(23, flatbuffers.number_types.UOffsetTFlags.py_type(MOTOR), 0)
+
+def AddMOTOR(builder, MOTOR):
+    MSLAddMOTOR(builder, MOTOR)
+
+def MSLAddGUIDANCE_CMD(builder, GUIDANCE_CMD):
+    builder.PrependUOffsetTRelativeSlot(24, flatbuffers.number_types.UOffsetTFlags.py_type(GUIDANCE_CMD), 0)
+
+def AddGUIDANCE_CMD(builder, GUIDANCE_CMD):
+    MSLAddGUIDANCE_CMD(builder, GUIDANCE_CMD)
+
+def MSLAddPHASE(builder, PHASE):
+    builder.PrependUint8Slot(25, PHASE, 0)
+
+def AddPHASE(builder, PHASE):
+    MSLAddPHASE(builder, PHASE)
+
+def MSLAddGUIDANCE_LAW(builder, GUIDANCE_LAW):
+    builder.PrependUint8Slot(26, GUIDANCE_LAW, 0)
+
+def AddGUIDANCE_LAW(builder, GUIDANCE_LAW):
+    MSLAddGUIDANCE_LAW(builder, GUIDANCE_LAW)
+
+def MSLAddTYPE(builder, TYPE):
+    builder.PrependUint8Slot(27, TYPE, 0)
+
+def AddTYPE(builder, TYPE):
+    MSLAddTYPE(builder, TYPE)
+
+def MSLAddARMED(builder, ARMED):
+    builder.PrependUint8Slot(28, ARMED, 0)
+
+def AddARMED(builder, ARMED):
+    MSLAddARMED(builder, ARMED)
+
+def MSLAddTIME_OF_FLIGHT(builder, TIME_OF_FLIGHT):
+    builder.PrependFloat32Slot(29, TIME_OF_FLIGHT, 0.0)
+
+def AddTIME_OF_FLIGHT(builder, TIME_OF_FLIGHT):
+    MSLAddTIME_OF_FLIGHT(builder, TIME_OF_FLIGHT)
+
+def MSLAddMAX_G(builder, MAX_G):
+    builder.PrependFloat32Slot(30, MAX_G, 0.0)
+
+def AddMAX_G(builder, MAX_G):
+    MSLAddMAX_G(builder, MAX_G)
+
+def MSLAddRESERVED(builder, RESERVED):
+    builder.PrependUOffsetTRelativeSlot(31, flatbuffers.number_types.UOffsetTFlags.py_type(RESERVED), 0)
+
+def AddRESERVED(builder, RESERVED):
+    MSLAddRESERVED(builder, RESERVED)
+
+def MSLStartRESERVEDVector(builder, numElems):
+    return builder.StartVector(1, numElems, 1)
+
+def StartRESERVEDVector(builder, numElems):
+    return MSLStartRESERVEDVector(builder, numElems)
+
+def MSLEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return MSLEnd(builder)
+
+try:
+    from typing import List
+except:
+    pass
+
+class MSLT(object):
+
+    # MSLT
+    def __init__(self):
+        self.POSITION_X = 0.0  # type: float
+        self.POSITION_Y = 0.0  # type: float
+        self.POSITION_Z = 0.0  # type: float
+        self.VELOCITY_X = 0.0  # type: float
+        self.VELOCITY_Y = 0.0  # type: float
+        self.VELOCITY_Z = 0.0  # type: float
+        self.ATTITUDE_X = 0.0  # type: float
+        self.ATTITUDE_Y = 0.0  # type: float
+        self.ATTITUDE_Z = 0.0  # type: float
+        self.ATTITUDE_W = 0.0  # type: float
+        self.OMEGA_X = 0.0  # type: float
+        self.OMEGA_Y = 0.0  # type: float
+        self.OMEGA_Z = 0.0  # type: float
+        self.MASS = 0.0  # type: float
+        self.MASS_INITIAL = 0.0  # type: float
+        self.TARGET_POSITION_X = 0.0  # type: float
+        self.TARGET_POSITION_Y = 0.0  # type: float
+        self.TARGET_POSITION_Z = 0.0  # type: float
+        self.TARGET_VELOCITY_X = 0.0  # type: float
+        self.TARGET_VELOCITY_Y = 0.0  # type: float
+        self.TARGET_VELOCITY_Z = 0.0  # type: float
+        self.MISS_DISTANCE = 0.0  # type: float
+        self.SEEKER = None  # type: str
+        self.MOTOR = None  # type: str
+        self.GUIDANCE_CMD = None  # type: str
+        self.PHASE = 0  # type: int
+        self.GUIDANCE_LAW = 0  # type: int
+        self.TYPE = 0  # type: int
+        self.ARMED = 0  # type: int
+        self.TIME_OF_FLIGHT = 0.0  # type: float
+        self.MAX_G = 0.0  # type: float
+        self.RESERVED = None  # type: List[int]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        MSL = MSL()
+        MSL.Init(buf, pos)
+        return cls.InitFromObj(MSL)
+
+    @classmethod
+    def InitFromPackedBuf(cls, buf, pos=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
+        return cls.InitFromBuf(buf, pos+n)
+
+    @classmethod
+    def InitFromObj(cls, MSL):
+        x = MSLT()
+        x._UnPack(MSL)
+        return x
+
+    # MSLT
+    def _UnPack(self, MSL):
+        if MSL is None:
+            return
+        self.POSITION_X = MSL.POSITION_X()
+        self.POSITION_Y = MSL.POSITION_Y()
+        self.POSITION_Z = MSL.POSITION_Z()
+        self.VELOCITY_X = MSL.VELOCITY_X()
+        self.VELOCITY_Y = MSL.VELOCITY_Y()
+        self.VELOCITY_Z = MSL.VELOCITY_Z()
+        self.ATTITUDE_X = MSL.ATTITUDE_X()
+        self.ATTITUDE_Y = MSL.ATTITUDE_Y()
+        self.ATTITUDE_Z = MSL.ATTITUDE_Z()
+        self.ATTITUDE_W = MSL.ATTITUDE_W()
+        self.OMEGA_X = MSL.OMEGA_X()
+        self.OMEGA_Y = MSL.OMEGA_Y()
+        self.OMEGA_Z = MSL.OMEGA_Z()
+        self.MASS = MSL.MASS()
+        self.MASS_INITIAL = MSL.MASS_INITIAL()
+        self.TARGET_POSITION_X = MSL.TARGET_POSITION_X()
+        self.TARGET_POSITION_Y = MSL.TARGET_POSITION_Y()
+        self.TARGET_POSITION_Z = MSL.TARGET_POSITION_Z()
+        self.TARGET_VELOCITY_X = MSL.TARGET_VELOCITY_X()
+        self.TARGET_VELOCITY_Y = MSL.TARGET_VELOCITY_Y()
+        self.TARGET_VELOCITY_Z = MSL.TARGET_VELOCITY_Z()
+        self.MISS_DISTANCE = MSL.MISS_DISTANCE()
+        self.SEEKER = MSL.SEEKER()
+        self.MOTOR = MSL.MOTOR()
+        self.GUIDANCE_CMD = MSL.GUIDANCE_CMD()
+        self.PHASE = MSL.PHASE()
+        self.GUIDANCE_LAW = MSL.GUIDANCE_LAW()
+        self.TYPE = MSL.TYPE()
+        self.ARMED = MSL.ARMED()
+        self.TIME_OF_FLIGHT = MSL.TIME_OF_FLIGHT()
+        self.MAX_G = MSL.MAX_G()
+        if not MSL.RESERVEDIsNone():
+            if np is None:
+                self.RESERVED = []
+                for i in range(MSL.RESERVEDLength()):
+                    self.RESERVED.append(MSL.RESERVED(i))
+            else:
+                self.RESERVED = MSL.RESERVEDAsNumpy()
+
+    # MSLT
+    def Pack(self, builder):
+        if self.SEEKER is not None:
+            SEEKER = builder.CreateString(self.SEEKER)
+        if self.MOTOR is not None:
+            MOTOR = builder.CreateString(self.MOTOR)
+        if self.GUIDANCE_CMD is not None:
+            GUIDANCE_CMD = builder.CreateString(self.GUIDANCE_CMD)
+        if self.RESERVED is not None:
+            if np is not None and type(self.RESERVED) is np.ndarray:
+                RESERVED = builder.CreateNumpyVector(self.RESERVED)
+            else:
+                MSLStartRESERVEDVector(builder, len(self.RESERVED))
+                for i in reversed(range(len(self.RESERVED))):
+                    builder.PrependUint8(self.RESERVED[i])
+                RESERVED = builder.EndVector()
+        MSLStart(builder)
+        MSLAddPOSITION_X(builder, self.POSITION_X)
+        MSLAddPOSITION_Y(builder, self.POSITION_Y)
+        MSLAddPOSITION_Z(builder, self.POSITION_Z)
+        MSLAddVELOCITY_X(builder, self.VELOCITY_X)
+        MSLAddVELOCITY_Y(builder, self.VELOCITY_Y)
+        MSLAddVELOCITY_Z(builder, self.VELOCITY_Z)
+        MSLAddATTITUDE_X(builder, self.ATTITUDE_X)
+        MSLAddATTITUDE_Y(builder, self.ATTITUDE_Y)
+        MSLAddATTITUDE_Z(builder, self.ATTITUDE_Z)
+        MSLAddATTITUDE_W(builder, self.ATTITUDE_W)
+        MSLAddOMEGA_X(builder, self.OMEGA_X)
+        MSLAddOMEGA_Y(builder, self.OMEGA_Y)
+        MSLAddOMEGA_Z(builder, self.OMEGA_Z)
+        MSLAddMASS(builder, self.MASS)
+        MSLAddMASS_INITIAL(builder, self.MASS_INITIAL)
+        MSLAddTARGET_POSITION_X(builder, self.TARGET_POSITION_X)
+        MSLAddTARGET_POSITION_Y(builder, self.TARGET_POSITION_Y)
+        MSLAddTARGET_POSITION_Z(builder, self.TARGET_POSITION_Z)
+        MSLAddTARGET_VELOCITY_X(builder, self.TARGET_VELOCITY_X)
+        MSLAddTARGET_VELOCITY_Y(builder, self.TARGET_VELOCITY_Y)
+        MSLAddTARGET_VELOCITY_Z(builder, self.TARGET_VELOCITY_Z)
+        MSLAddMISS_DISTANCE(builder, self.MISS_DISTANCE)
+        if self.SEEKER is not None:
+            MSLAddSEEKER(builder, SEEKER)
+        if self.MOTOR is not None:
+            MSLAddMOTOR(builder, MOTOR)
+        if self.GUIDANCE_CMD is not None:
+            MSLAddGUIDANCE_CMD(builder, GUIDANCE_CMD)
+        MSLAddPHASE(builder, self.PHASE)
+        MSLAddGUIDANCE_LAW(builder, self.GUIDANCE_LAW)
+        MSLAddTYPE(builder, self.TYPE)
+        MSLAddARMED(builder, self.ARMED)
+        MSLAddTIME_OF_FLIGHT(builder, self.TIME_OF_FLIGHT)
+        MSLAddMAX_G(builder, self.MAX_G)
+        if self.RESERVED is not None:
+            MSLAddRESERVED(builder, RESERVED)
+        MSL = MSLEnd(builder)
+        return MSL

MSL/MissilePhase.py

@@ -0,0 +1,14 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+class MissilePhase(object):
+    CAPTIVE = 0
+    LAUNCH = 1
+    BOOST = 2
+    SUSTAIN = 3
+    COAST = 4
+    TERMINAL = 5
+    INTERCEPT = 6
+    MISS = 7
+    SELF_DESTRUCT = 8

MSL/MissileType.py

@@ -0,0 +1,20 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+class MissileType(object):
+    AAM_IR = 0
+    AAM_SARH = 1
+    AAM_ARH = 2
+    SAM_IR = 3
+    SAM_SARH = 4
+    SAM_COMMAND = 5
+    ASM_AR = 6
+    ASM_TV = 7
+    ASM_LASER = 8
+    ATGM_SACLOS = 9
+    ATGM_BEAM = 10
+    ATGM_TOP = 11
+    CRUISE = 12
+    BALLISTIC = 13
+    TORPEDO = 14

MSL/SeekerStatus.py

@@ -0,0 +1,12 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+class SeekerStatus(object):
+    OFF = 0
+    CAGED = 1
+    UNCAGED = 2
+    ACQUIRING = 3
+    TRACKING = 4
+    MEMORY = 5
+    JAMMED = 6

MSL/SeekerType.py

@@ -0,0 +1,18 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+class SeekerType(object):
+    NONE = 0
+    IR_UNCOOLED = 1
+    IR_COOLED = 2
+    IR_IMAGING = 3
+    IR_2COLOR = 4
+    RADAR_SARH = 5
+    RADAR_ARH = 6
+    RADAR_PASSIVE = 7
+    TV_OPTICAL = 8
+    LASER_SH = 9
+    GPS_INS = 10
+    ACOUSTIC = 11
+    WIRE = 12