spacedatastandards.org 1.73.0__py3-none-any.whl

NAV/NAV.py

@@ -0,0 +1,687 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Naval Vessels
+class NAV(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = NAV()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsNAV(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def NAVBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x4E\x41\x56", size_prefixed=size_prefixed)
+
+    # NAV
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # NAV
+    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
+
+    # NAV
+    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
+
+    # NAV
+    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
+
+    # NAV
+    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
+
+    # NAV
+    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
+
+    # NAV
+    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
+
+    # NAV
+    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
+
+    # NAV
+    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
+
+    # NAV
+    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
+
+    # NAV
+    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
+
+    # NAV
+    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
+
+    # NAV
+    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
+
+    # NAV
+    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
+
+    # NAV
+    def SPEED_KNOTS(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 0.0
+
+    # NAV
+    def HEADING(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 0.0
+
+    # NAV
+    def COURSE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 0.0
+
+    # NAV
+    def RUDDER_ANGLE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 0.0
+
+    # NAV
+    def HULL(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(38))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # NAV
+    def PROPULSION(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(40))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # NAV
+    def DC_STATE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(42))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # NAV
+    def FIRES_ACTIVE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(44))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # NAV
+    def FLOODING_ACTIVE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(46))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # NAV
+    def CREW_CASUALTIES(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(48))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # NAV
+    def HULL_INTEGRITY(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(50))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 0.0
+
+    # NAV
+    def POWER_AVAILABLE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 0.0
+
+    # NAV
+    def WEAPONS_ONLINE(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
+
+    # NAV
+    def SENSORS_ONLINE(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
+
+    # NAV
+    def RESERVED1(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(58))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
+        return 0
+
+    # NAV
+    def FUEL_REMAINING(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(60))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 0.0
+
+    # NAV
+    def AMMO_MAIN(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(62))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
+        return 0
+
+    # NAV
+    def MISSILES_REMAINING(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # NAV
+    def TORPEDOES_REMAINING(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(66))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # NAV
+    def VESSEL_TYPE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # NAV
+    def PROPULSION_TYPE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # NAV
+    def RESERVED(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(72))
+        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
+
+    # NAV
+    def RESERVEDAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(72))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # NAV
+    def RESERVEDLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(72))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # NAV
+    def RESERVEDIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(72))
+        return o == 0
+
+def NAVStart(builder):
+    builder.StartObject(35)
+
+def Start(builder):
+    NAVStart(builder)
+
+def NAVAddPOSITION_X(builder, POSITION_X):
+    builder.PrependFloat64Slot(0, POSITION_X, 0.0)
+
+def AddPOSITION_X(builder, POSITION_X):
+    NAVAddPOSITION_X(builder, POSITION_X)
+
+def NAVAddPOSITION_Y(builder, POSITION_Y):
+    builder.PrependFloat64Slot(1, POSITION_Y, 0.0)
+
+def AddPOSITION_Y(builder, POSITION_Y):
+    NAVAddPOSITION_Y(builder, POSITION_Y)
+
+def NAVAddPOSITION_Z(builder, POSITION_Z):
+    builder.PrependFloat64Slot(2, POSITION_Z, 0.0)
+
+def AddPOSITION_Z(builder, POSITION_Z):
+    NAVAddPOSITION_Z(builder, POSITION_Z)
+
+def NAVAddVELOCITY_X(builder, VELOCITY_X):
+    builder.PrependFloat64Slot(3, VELOCITY_X, 0.0)
+
+def AddVELOCITY_X(builder, VELOCITY_X):
+    NAVAddVELOCITY_X(builder, VELOCITY_X)
+
+def NAVAddVELOCITY_Y(builder, VELOCITY_Y):
+    builder.PrependFloat64Slot(4, VELOCITY_Y, 0.0)
+
+def AddVELOCITY_Y(builder, VELOCITY_Y):
+    NAVAddVELOCITY_Y(builder, VELOCITY_Y)
+
+def NAVAddVELOCITY_Z(builder, VELOCITY_Z):
+    builder.PrependFloat64Slot(5, VELOCITY_Z, 0.0)
+
+def AddVELOCITY_Z(builder, VELOCITY_Z):
+    NAVAddVELOCITY_Z(builder, VELOCITY_Z)
+
+def NAVAddATTITUDE_X(builder, ATTITUDE_X):
+    builder.PrependFloat64Slot(6, ATTITUDE_X, 0.0)
+
+def AddATTITUDE_X(builder, ATTITUDE_X):
+    NAVAddATTITUDE_X(builder, ATTITUDE_X)
+
+def NAVAddATTITUDE_Y(builder, ATTITUDE_Y):
+    builder.PrependFloat64Slot(7, ATTITUDE_Y, 0.0)
+
+def AddATTITUDE_Y(builder, ATTITUDE_Y):
+    NAVAddATTITUDE_Y(builder, ATTITUDE_Y)
+
+def NAVAddATTITUDE_Z(builder, ATTITUDE_Z):
+    builder.PrependFloat64Slot(8, ATTITUDE_Z, 0.0)
+
+def AddATTITUDE_Z(builder, ATTITUDE_Z):
+    NAVAddATTITUDE_Z(builder, ATTITUDE_Z)
+
+def NAVAddATTITUDE_W(builder, ATTITUDE_W):
+    builder.PrependFloat64Slot(9, ATTITUDE_W, 0.0)
+
+def AddATTITUDE_W(builder, ATTITUDE_W):
+    NAVAddATTITUDE_W(builder, ATTITUDE_W)
+
+def NAVAddOMEGA_X(builder, OMEGA_X):
+    builder.PrependFloat64Slot(10, OMEGA_X, 0.0)
+
+def AddOMEGA_X(builder, OMEGA_X):
+    NAVAddOMEGA_X(builder, OMEGA_X)
+
+def NAVAddOMEGA_Y(builder, OMEGA_Y):
+    builder.PrependFloat64Slot(11, OMEGA_Y, 0.0)
+
+def AddOMEGA_Y(builder, OMEGA_Y):
+    NAVAddOMEGA_Y(builder, OMEGA_Y)
+
+def NAVAddOMEGA_Z(builder, OMEGA_Z):
+    builder.PrependFloat64Slot(12, OMEGA_Z, 0.0)
+
+def AddOMEGA_Z(builder, OMEGA_Z):
+    NAVAddOMEGA_Z(builder, OMEGA_Z)
+
+def NAVAddSPEED_KNOTS(builder, SPEED_KNOTS):
+    builder.PrependFloat32Slot(13, SPEED_KNOTS, 0.0)
+
+def AddSPEED_KNOTS(builder, SPEED_KNOTS):
+    NAVAddSPEED_KNOTS(builder, SPEED_KNOTS)
+
+def NAVAddHEADING(builder, HEADING):
+    builder.PrependFloat32Slot(14, HEADING, 0.0)
+
+def AddHEADING(builder, HEADING):
+    NAVAddHEADING(builder, HEADING)
+
+def NAVAddCOURSE(builder, COURSE):
+    builder.PrependFloat32Slot(15, COURSE, 0.0)
+
+def AddCOURSE(builder, COURSE):
+    NAVAddCOURSE(builder, COURSE)
+
+def NAVAddRUDDER_ANGLE(builder, RUDDER_ANGLE):
+    builder.PrependFloat32Slot(16, RUDDER_ANGLE, 0.0)
+
+def AddRUDDER_ANGLE(builder, RUDDER_ANGLE):
+    NAVAddRUDDER_ANGLE(builder, RUDDER_ANGLE)
+
+def NAVAddHULL(builder, HULL):
+    builder.PrependUOffsetTRelativeSlot(17, flatbuffers.number_types.UOffsetTFlags.py_type(HULL), 0)
+
+def AddHULL(builder, HULL):
+    NAVAddHULL(builder, HULL)
+
+def NAVAddPROPULSION(builder, PROPULSION):
+    builder.PrependUOffsetTRelativeSlot(18, flatbuffers.number_types.UOffsetTFlags.py_type(PROPULSION), 0)
+
+def AddPROPULSION(builder, PROPULSION):
+    NAVAddPROPULSION(builder, PROPULSION)
+
+def NAVAddDC_STATE(builder, DC_STATE):
+    builder.PrependUint8Slot(19, DC_STATE, 0)
+
+def AddDC_STATE(builder, DC_STATE):
+    NAVAddDC_STATE(builder, DC_STATE)
+
+def NAVAddFIRES_ACTIVE(builder, FIRES_ACTIVE):
+    builder.PrependUint8Slot(20, FIRES_ACTIVE, 0)
+
+def AddFIRES_ACTIVE(builder, FIRES_ACTIVE):
+    NAVAddFIRES_ACTIVE(builder, FIRES_ACTIVE)
+
+def NAVAddFLOODING_ACTIVE(builder, FLOODING_ACTIVE):
+    builder.PrependUint8Slot(21, FLOODING_ACTIVE, 0)
+
+def AddFLOODING_ACTIVE(builder, FLOODING_ACTIVE):
+    NAVAddFLOODING_ACTIVE(builder, FLOODING_ACTIVE)
+
+def NAVAddCREW_CASUALTIES(builder, CREW_CASUALTIES):
+    builder.PrependUint8Slot(22, CREW_CASUALTIES, 0)
+
+def AddCREW_CASUALTIES(builder, CREW_CASUALTIES):
+    NAVAddCREW_CASUALTIES(builder, CREW_CASUALTIES)
+
+def NAVAddHULL_INTEGRITY(builder, HULL_INTEGRITY):
+    builder.PrependFloat32Slot(23, HULL_INTEGRITY, 0.0)
+
+def AddHULL_INTEGRITY(builder, HULL_INTEGRITY):
+    NAVAddHULL_INTEGRITY(builder, HULL_INTEGRITY)
+
+def NAVAddPOWER_AVAILABLE(builder, POWER_AVAILABLE):
+    builder.PrependFloat32Slot(24, POWER_AVAILABLE, 0.0)
+
+def AddPOWER_AVAILABLE(builder, POWER_AVAILABLE):
+    NAVAddPOWER_AVAILABLE(builder, POWER_AVAILABLE)
+
+def NAVAddWEAPONS_ONLINE(builder, WEAPONS_ONLINE):
+    builder.PrependUint8Slot(25, WEAPONS_ONLINE, 0)
+
+def AddWEAPONS_ONLINE(builder, WEAPONS_ONLINE):
+    NAVAddWEAPONS_ONLINE(builder, WEAPONS_ONLINE)
+
+def NAVAddSENSORS_ONLINE(builder, SENSORS_ONLINE):
+    builder.PrependUint8Slot(26, SENSORS_ONLINE, 0)
+
+def AddSENSORS_ONLINE(builder, SENSORS_ONLINE):
+    NAVAddSENSORS_ONLINE(builder, SENSORS_ONLINE)
+
+def NAVAddRESERVED1(builder, RESERVED1):
+    builder.PrependUint16Slot(27, RESERVED1, 0)
+
+def AddRESERVED1(builder, RESERVED1):
+    NAVAddRESERVED1(builder, RESERVED1)
+
+def NAVAddFUEL_REMAINING(builder, FUEL_REMAINING):
+    builder.PrependFloat32Slot(28, FUEL_REMAINING, 0.0)
+
+def AddFUEL_REMAINING(builder, FUEL_REMAINING):
+    NAVAddFUEL_REMAINING(builder, FUEL_REMAINING)
+
+def NAVAddAMMO_MAIN(builder, AMMO_MAIN):
+    builder.PrependUint16Slot(29, AMMO_MAIN, 0)
+
+def AddAMMO_MAIN(builder, AMMO_MAIN):
+    NAVAddAMMO_MAIN(builder, AMMO_MAIN)
+
+def NAVAddMISSILES_REMAINING(builder, MISSILES_REMAINING):
+    builder.PrependUint8Slot(30, MISSILES_REMAINING, 0)
+
+def AddMISSILES_REMAINING(builder, MISSILES_REMAINING):
+    NAVAddMISSILES_REMAINING(builder, MISSILES_REMAINING)
+
+def NAVAddTORPEDOES_REMAINING(builder, TORPEDOES_REMAINING):
+    builder.PrependUint8Slot(31, TORPEDOES_REMAINING, 0)
+
+def AddTORPEDOES_REMAINING(builder, TORPEDOES_REMAINING):
+    NAVAddTORPEDOES_REMAINING(builder, TORPEDOES_REMAINING)
+
+def NAVAddVESSEL_TYPE(builder, VESSEL_TYPE):
+    builder.PrependUint8Slot(32, VESSEL_TYPE, 0)
+
+def AddVESSEL_TYPE(builder, VESSEL_TYPE):
+    NAVAddVESSEL_TYPE(builder, VESSEL_TYPE)
+
+def NAVAddPROPULSION_TYPE(builder, PROPULSION_TYPE):
+    builder.PrependUint8Slot(33, PROPULSION_TYPE, 0)
+
+def AddPROPULSION_TYPE(builder, PROPULSION_TYPE):
+    NAVAddPROPULSION_TYPE(builder, PROPULSION_TYPE)
+
+def NAVAddRESERVED(builder, RESERVED):
+    builder.PrependUOffsetTRelativeSlot(34, flatbuffers.number_types.UOffsetTFlags.py_type(RESERVED), 0)
+
+def AddRESERVED(builder, RESERVED):
+    NAVAddRESERVED(builder, RESERVED)
+
+def NAVStartRESERVEDVector(builder, numElems):
+    return builder.StartVector(1, numElems, 1)
+
+def StartRESERVEDVector(builder, numElems):
+    return NAVStartRESERVEDVector(builder, numElems)
+
+def NAVEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return NAVEnd(builder)
+
+try:
+    from typing import List
+except:
+    pass
+
+class NAVT(object):
+
+    # NAVT
+    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.SPEED_KNOTS = 0.0  # type: float
+        self.HEADING = 0.0  # type: float
+        self.COURSE = 0.0  # type: float
+        self.RUDDER_ANGLE = 0.0  # type: float
+        self.HULL = None  # type: str
+        self.PROPULSION = None  # type: str
+        self.DC_STATE = 0  # type: int
+        self.FIRES_ACTIVE = 0  # type: int
+        self.FLOODING_ACTIVE = 0  # type: int
+        self.CREW_CASUALTIES = 0  # type: int
+        self.HULL_INTEGRITY = 0.0  # type: float
+        self.POWER_AVAILABLE = 0.0  # type: float
+        self.WEAPONS_ONLINE = 0  # type: int
+        self.SENSORS_ONLINE = 0  # type: int
+        self.RESERVED1 = 0  # type: int
+        self.FUEL_REMAINING = 0.0  # type: float
+        self.AMMO_MAIN = 0  # type: int
+        self.MISSILES_REMAINING = 0  # type: int
+        self.TORPEDOES_REMAINING = 0  # type: int
+        self.VESSEL_TYPE = 0  # type: int
+        self.PROPULSION_TYPE = 0  # type: int
+        self.RESERVED = None  # type: List[int]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        NAV = NAV()
+        NAV.Init(buf, pos)
+        return cls.InitFromObj(NAV)
+
+    @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, NAV):
+        x = NAVT()
+        x._UnPack(NAV)
+        return x
+
+    # NAVT
+    def _UnPack(self, NAV):
+        if NAV is None:
+            return
+        self.POSITION_X = NAV.POSITION_X()
+        self.POSITION_Y = NAV.POSITION_Y()
+        self.POSITION_Z = NAV.POSITION_Z()
+        self.VELOCITY_X = NAV.VELOCITY_X()
+        self.VELOCITY_Y = NAV.VELOCITY_Y()
+        self.VELOCITY_Z = NAV.VELOCITY_Z()
+        self.ATTITUDE_X = NAV.ATTITUDE_X()
+        self.ATTITUDE_Y = NAV.ATTITUDE_Y()
+        self.ATTITUDE_Z = NAV.ATTITUDE_Z()
+        self.ATTITUDE_W = NAV.ATTITUDE_W()
+        self.OMEGA_X = NAV.OMEGA_X()
+        self.OMEGA_Y = NAV.OMEGA_Y()
+        self.OMEGA_Z = NAV.OMEGA_Z()
+        self.SPEED_KNOTS = NAV.SPEED_KNOTS()
+        self.HEADING = NAV.HEADING()
+        self.COURSE = NAV.COURSE()
+        self.RUDDER_ANGLE = NAV.RUDDER_ANGLE()
+        self.HULL = NAV.HULL()
+        self.PROPULSION = NAV.PROPULSION()
+        self.DC_STATE = NAV.DC_STATE()
+        self.FIRES_ACTIVE = NAV.FIRES_ACTIVE()
+        self.FLOODING_ACTIVE = NAV.FLOODING_ACTIVE()
+        self.CREW_CASUALTIES = NAV.CREW_CASUALTIES()
+        self.HULL_INTEGRITY = NAV.HULL_INTEGRITY()
+        self.POWER_AVAILABLE = NAV.POWER_AVAILABLE()
+        self.WEAPONS_ONLINE = NAV.WEAPONS_ONLINE()
+        self.SENSORS_ONLINE = NAV.SENSORS_ONLINE()
+        self.RESERVED1 = NAV.RESERVED1()
+        self.FUEL_REMAINING = NAV.FUEL_REMAINING()
+        self.AMMO_MAIN = NAV.AMMO_MAIN()
+        self.MISSILES_REMAINING = NAV.MISSILES_REMAINING()
+        self.TORPEDOES_REMAINING = NAV.TORPEDOES_REMAINING()
+        self.VESSEL_TYPE = NAV.VESSEL_TYPE()
+        self.PROPULSION_TYPE = NAV.PROPULSION_TYPE()
+        if not NAV.RESERVEDIsNone():
+            if np is None:
+                self.RESERVED = []
+                for i in range(NAV.RESERVEDLength()):
+                    self.RESERVED.append(NAV.RESERVED(i))
+            else:
+                self.RESERVED = NAV.RESERVEDAsNumpy()
+
+    # NAVT
+    def Pack(self, builder):
+        if self.HULL is not None:
+            HULL = builder.CreateString(self.HULL)
+        if self.PROPULSION is not None:
+            PROPULSION = builder.CreateString(self.PROPULSION)
+        if self.RESERVED is not None:
+            if np is not None and type(self.RESERVED) is np.ndarray:
+                RESERVED = builder.CreateNumpyVector(self.RESERVED)
+            else:
+                NAVStartRESERVEDVector(builder, len(self.RESERVED))
+                for i in reversed(range(len(self.RESERVED))):
+                    builder.PrependUint8(self.RESERVED[i])
+                RESERVED = builder.EndVector()
+        NAVStart(builder)
+        NAVAddPOSITION_X(builder, self.POSITION_X)
+        NAVAddPOSITION_Y(builder, self.POSITION_Y)
+        NAVAddPOSITION_Z(builder, self.POSITION_Z)
+        NAVAddVELOCITY_X(builder, self.VELOCITY_X)
+        NAVAddVELOCITY_Y(builder, self.VELOCITY_Y)
+        NAVAddVELOCITY_Z(builder, self.VELOCITY_Z)
+        NAVAddATTITUDE_X(builder, self.ATTITUDE_X)
+        NAVAddATTITUDE_Y(builder, self.ATTITUDE_Y)
+        NAVAddATTITUDE_Z(builder, self.ATTITUDE_Z)
+        NAVAddATTITUDE_W(builder, self.ATTITUDE_W)
+        NAVAddOMEGA_X(builder, self.OMEGA_X)
+        NAVAddOMEGA_Y(builder, self.OMEGA_Y)
+        NAVAddOMEGA_Z(builder, self.OMEGA_Z)
+        NAVAddSPEED_KNOTS(builder, self.SPEED_KNOTS)
+        NAVAddHEADING(builder, self.HEADING)
+        NAVAddCOURSE(builder, self.COURSE)
+        NAVAddRUDDER_ANGLE(builder, self.RUDDER_ANGLE)
+        if self.HULL is not None:
+            NAVAddHULL(builder, HULL)
+        if self.PROPULSION is not None:
+            NAVAddPROPULSION(builder, PROPULSION)
+        NAVAddDC_STATE(builder, self.DC_STATE)
+        NAVAddFIRES_ACTIVE(builder, self.FIRES_ACTIVE)
+        NAVAddFLOODING_ACTIVE(builder, self.FLOODING_ACTIVE)
+        NAVAddCREW_CASUALTIES(builder, self.CREW_CASUALTIES)
+        NAVAddHULL_INTEGRITY(builder, self.HULL_INTEGRITY)
+        NAVAddPOWER_AVAILABLE(builder, self.POWER_AVAILABLE)
+        NAVAddWEAPONS_ONLINE(builder, self.WEAPONS_ONLINE)
+        NAVAddSENSORS_ONLINE(builder, self.SENSORS_ONLINE)
+        NAVAddRESERVED1(builder, self.RESERVED1)
+        NAVAddFUEL_REMAINING(builder, self.FUEL_REMAINING)
+        NAVAddAMMO_MAIN(builder, self.AMMO_MAIN)
+        NAVAddMISSILES_REMAINING(builder, self.MISSILES_REMAINING)
+        NAVAddTORPEDOES_REMAINING(builder, self.TORPEDOES_REMAINING)
+        NAVAddVESSEL_TYPE(builder, self.VESSEL_TYPE)
+        NAVAddPROPULSION_TYPE(builder, self.PROPULSION_TYPE)
+        if self.RESERVED is not None:
+            NAVAddRESERVED(builder, RESERVED)
+        NAV = NAVEnd(builder)
+        return NAV

NAV/PropulsionType.py

@@ -0,0 +1,14 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+class PropulsionType(object):
+    STEAM = 0
+    GAS_TURBINE = 1
+    DIESEL = 2
+    DIESEL_ELECTRIC = 3
+    NUCLEAR = 4
+    CODAG = 5
+    COGAG = 6
+    CODLAG = 7
+    AIP = 8