1614 lines
76 KiB
Python
1614 lines
76 KiB
Python
# automatically generated by the FlatBuffers compiler, do not modify
|
|
|
|
# namespace: Example
|
|
|
|
import flatbuffers
|
|
from flatbuffers.compat import import_numpy
|
|
np = import_numpy()
|
|
|
|
# an example documentation comment: "monster object"
|
|
class Monster(object):
|
|
__slots__ = ['_tab']
|
|
|
|
@classmethod
|
|
def GetRootAs(cls, buf, offset=0):
|
|
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
|
|
x = Monster()
|
|
x.Init(buf, n + offset)
|
|
return x
|
|
|
|
@classmethod
|
|
def GetRootAsMonster(cls, buf, offset=0):
|
|
"""This method is deprecated. Please switch to GetRootAs."""
|
|
return cls.GetRootAs(buf, offset)
|
|
@classmethod
|
|
def MonsterBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
|
|
return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x4F\x4E\x53", size_prefixed=size_prefixed)
|
|
|
|
# Monster
|
|
def Init(self, buf, pos):
|
|
self._tab = flatbuffers.table.Table(buf, pos)
|
|
|
|
# Monster
|
|
def Pos(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
|
|
if o != 0:
|
|
x = o + self._tab.Pos
|
|
from MyGame.Example.Vec3 import Vec3
|
|
obj = Vec3()
|
|
obj.Init(self._tab.Bytes, x)
|
|
return obj
|
|
return None
|
|
|
|
# Monster
|
|
def Mana(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Int16Flags, o + self._tab.Pos)
|
|
return 150
|
|
|
|
# Monster
|
|
def Hp(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Int16Flags, o + self._tab.Pos)
|
|
return 100
|
|
|
|
# Monster
|
|
def Name(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
|
|
if o != 0:
|
|
return self._tab.String(o + self._tab.Pos)
|
|
return None
|
|
|
|
# Monster
|
|
def Inventory(self, j):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
|
|
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
|
|
|
|
# Monster
|
|
def InventoryAsNumpy(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
|
|
if o != 0:
|
|
return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
|
|
return 0
|
|
|
|
# Monster
|
|
def InventoryLength(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
|
|
if o != 0:
|
|
return self._tab.VectorLen(o)
|
|
return 0
|
|
|
|
# Monster
|
|
def InventoryIsNone(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
|
|
return o == 0
|
|
|
|
# Monster
|
|
def Color(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
|
|
return 8
|
|
|
|
# Monster
|
|
def TestType(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
|
|
return 0
|
|
|
|
# Monster
|
|
def Test(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
|
|
if o != 0:
|
|
from flatbuffers.table import Table
|
|
obj = Table(bytearray(), 0)
|
|
self._tab.Union(obj, o)
|
|
return obj
|
|
return None
|
|
|
|
# Monster
|
|
def Test4(self, j):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
|
|
if o != 0:
|
|
x = self._tab.Vector(o)
|
|
x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
|
|
from MyGame.Example.Test import Test
|
|
obj = Test()
|
|
obj.Init(self._tab.Bytes, x)
|
|
return obj
|
|
return None
|
|
|
|
# Monster
|
|
def Test4Length(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
|
|
if o != 0:
|
|
return self._tab.VectorLen(o)
|
|
return 0
|
|
|
|
# Monster
|
|
def Test4IsNone(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
|
|
return o == 0
|
|
|
|
# Monster
|
|
def Testarrayofstring(self, j):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
|
|
if o != 0:
|
|
a = self._tab.Vector(o)
|
|
return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
|
|
return ""
|
|
|
|
# Monster
|
|
def TestarrayofstringLength(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
|
|
if o != 0:
|
|
return self._tab.VectorLen(o)
|
|
return 0
|
|
|
|
# Monster
|
|
def TestarrayofstringIsNone(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
|
|
return o == 0
|
|
|
|
# an example documentation comment: this will end up in the generated code
|
|
# multiline too
|
|
# Monster
|
|
def Testarrayoftables(self, j):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
|
|
if o != 0:
|
|
x = self._tab.Vector(o)
|
|
x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
|
|
x = self._tab.Indirect(x)
|
|
from MyGame.Example.Monster import Monster
|
|
obj = Monster()
|
|
obj.Init(self._tab.Bytes, x)
|
|
return obj
|
|
return None
|
|
|
|
# Monster
|
|
def TestarrayoftablesLength(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
|
|
if o != 0:
|
|
return self._tab.VectorLen(o)
|
|
return 0
|
|
|
|
# Monster
|
|
def TestarrayoftablesIsNone(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
|
|
return o == 0
|
|
|
|
# Monster
|
|
def Enemy(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
|
|
if o != 0:
|
|
x = self._tab.Indirect(o + self._tab.Pos)
|
|
from MyGame.Example.Monster import Monster
|
|
obj = Monster()
|
|
obj.Init(self._tab.Bytes, x)
|
|
return obj
|
|
return None
|
|
|
|
# Monster
|
|
def Testnestedflatbuffer(self, j):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
|
|
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
|
|
|
|
# Monster
|
|
def TestnestedflatbufferAsNumpy(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
|
|
if o != 0:
|
|
return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
|
|
return 0
|
|
|
|
# Monster
|
|
def TestnestedflatbufferNestedRoot(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
|
|
if o != 0:
|
|
from MyGame.Example.Monster import Monster
|
|
return Monster.GetRootAs(self._tab.Bytes, self._tab.Vector(o))
|
|
return 0
|
|
|
|
# Monster
|
|
def TestnestedflatbufferLength(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
|
|
if o != 0:
|
|
return self._tab.VectorLen(o)
|
|
return 0
|
|
|
|
# Monster
|
|
def TestnestedflatbufferIsNone(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
|
|
return o == 0
|
|
|
|
# Monster
|
|
def Testempty(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
|
|
if o != 0:
|
|
x = self._tab.Indirect(o + self._tab.Pos)
|
|
from MyGame.Example.Stat import Stat
|
|
obj = Stat()
|
|
obj.Init(self._tab.Bytes, x)
|
|
return obj
|
|
return None
|
|
|
|
# Monster
|
|
def Testbool(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
|
|
if o != 0:
|
|
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
|
|
return False
|
|
|
|
# Monster
|
|
def Testhashs32Fnv1(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
|
|
return 0
|
|
|
|
# Monster
|
|
def Testhashu32Fnv1(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(38))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
|
|
return 0
|
|
|
|
# Monster
|
|
def Testhashs64Fnv1(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(40))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
|
|
return 0
|
|
|
|
# Monster
|
|
def Testhashu64Fnv1(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(42))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
|
|
return 0
|
|
|
|
# Monster
|
|
def Testhashs32Fnv1a(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(44))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
|
|
return 0
|
|
|
|
# Monster
|
|
def Testhashu32Fnv1a(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(46))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
|
|
return 0
|
|
|
|
# Monster
|
|
def Testhashs64Fnv1a(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(48))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
|
|
return 0
|
|
|
|
# Monster
|
|
def Testhashu64Fnv1a(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(50))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
|
|
return 0
|
|
|
|
# Monster
|
|
def Testarrayofbools(self, j):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
|
|
if o != 0:
|
|
a = self._tab.Vector(o)
|
|
return self._tab.Get(flatbuffers.number_types.BoolFlags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
|
|
return 0
|
|
|
|
# Monster
|
|
def TestarrayofboolsAsNumpy(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
|
|
if o != 0:
|
|
return self._tab.GetVectorAsNumpy(flatbuffers.number_types.BoolFlags, o)
|
|
return 0
|
|
|
|
# Monster
|
|
def TestarrayofboolsLength(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
|
|
if o != 0:
|
|
return self._tab.VectorLen(o)
|
|
return 0
|
|
|
|
# Monster
|
|
def TestarrayofboolsIsNone(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
|
|
return o == 0
|
|
|
|
# Monster
|
|
def Testf(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(54))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
|
|
return 3.14159
|
|
|
|
# Monster
|
|
def Testf2(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(56))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
|
|
return 3.0
|
|
|
|
# Monster
|
|
def Testf3(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(58))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
|
|
return 0.0
|
|
|
|
# Monster
|
|
def Testarrayofstring2(self, j):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(60))
|
|
if o != 0:
|
|
a = self._tab.Vector(o)
|
|
return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
|
|
return ""
|
|
|
|
# Monster
|
|
def Testarrayofstring2Length(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(60))
|
|
if o != 0:
|
|
return self._tab.VectorLen(o)
|
|
return 0
|
|
|
|
# Monster
|
|
def Testarrayofstring2IsNone(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(60))
|
|
return o == 0
|
|
|
|
# Monster
|
|
def Testarrayofsortedstruct(self, j):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(62))
|
|
if o != 0:
|
|
x = self._tab.Vector(o)
|
|
x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 8
|
|
from MyGame.Example.Ability import Ability
|
|
obj = Ability()
|
|
obj.Init(self._tab.Bytes, x)
|
|
return obj
|
|
return None
|
|
|
|
# Monster
|
|
def TestarrayofsortedstructLength(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(62))
|
|
if o != 0:
|
|
return self._tab.VectorLen(o)
|
|
return 0
|
|
|
|
# Monster
|
|
def TestarrayofsortedstructIsNone(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(62))
|
|
return o == 0
|
|
|
|
# Monster
|
|
def Flex(self, j):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
|
|
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
|
|
|
|
# Monster
|
|
def FlexAsNumpy(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
|
|
if o != 0:
|
|
return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
|
|
return 0
|
|
|
|
# Monster
|
|
def FlexLength(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
|
|
if o != 0:
|
|
return self._tab.VectorLen(o)
|
|
return 0
|
|
|
|
# Monster
|
|
def FlexIsNone(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
|
|
return o == 0
|
|
|
|
# Monster
|
|
def Test5(self, j):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(66))
|
|
if o != 0:
|
|
x = self._tab.Vector(o)
|
|
x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
|
|
from MyGame.Example.Test import Test
|
|
obj = Test()
|
|
obj.Init(self._tab.Bytes, x)
|
|
return obj
|
|
return None
|
|
|
|
# Monster
|
|
def Test5Length(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(66))
|
|
if o != 0:
|
|
return self._tab.VectorLen(o)
|
|
return 0
|
|
|
|
# Monster
|
|
def Test5IsNone(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(66))
|
|
return o == 0
|
|
|
|
# Monster
|
|
def VectorOfLongs(self, j):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
|
|
if o != 0:
|
|
a = self._tab.Vector(o)
|
|
return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
|
|
return 0
|
|
|
|
# Monster
|
|
def VectorOfLongsAsNumpy(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
|
|
if o != 0:
|
|
return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o)
|
|
return 0
|
|
|
|
# Monster
|
|
def VectorOfLongsLength(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
|
|
if o != 0:
|
|
return self._tab.VectorLen(o)
|
|
return 0
|
|
|
|
# Monster
|
|
def VectorOfLongsIsNone(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
|
|
return o == 0
|
|
|
|
# Monster
|
|
def VectorOfDoubles(self, j):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
|
|
if o != 0:
|
|
a = self._tab.Vector(o)
|
|
return self._tab.Get(flatbuffers.number_types.Float64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
|
|
return 0
|
|
|
|
# Monster
|
|
def VectorOfDoublesAsNumpy(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
|
|
if o != 0:
|
|
return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float64Flags, o)
|
|
return 0
|
|
|
|
# Monster
|
|
def VectorOfDoublesLength(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
|
|
if o != 0:
|
|
return self._tab.VectorLen(o)
|
|
return 0
|
|
|
|
# Monster
|
|
def VectorOfDoublesIsNone(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
|
|
return o == 0
|
|
|
|
# Monster
|
|
def ParentNamespaceTest(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(72))
|
|
if o != 0:
|
|
x = self._tab.Indirect(o + self._tab.Pos)
|
|
from MyGame.InParentNamespace import InParentNamespace
|
|
obj = InParentNamespace()
|
|
obj.Init(self._tab.Bytes, x)
|
|
return obj
|
|
return None
|
|
|
|
# Monster
|
|
def VectorOfReferrables(self, j):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(74))
|
|
if o != 0:
|
|
x = self._tab.Vector(o)
|
|
x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
|
|
x = self._tab.Indirect(x)
|
|
from MyGame.Example.Referrable import Referrable
|
|
obj = Referrable()
|
|
obj.Init(self._tab.Bytes, x)
|
|
return obj
|
|
return None
|
|
|
|
# Monster
|
|
def VectorOfReferrablesLength(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(74))
|
|
if o != 0:
|
|
return self._tab.VectorLen(o)
|
|
return 0
|
|
|
|
# Monster
|
|
def VectorOfReferrablesIsNone(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(74))
|
|
return o == 0
|
|
|
|
# Monster
|
|
def SingleWeakReference(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(76))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
|
|
return 0
|
|
|
|
# Monster
|
|
def VectorOfWeakReferences(self, j):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(78))
|
|
if o != 0:
|
|
a = self._tab.Vector(o)
|
|
return self._tab.Get(flatbuffers.number_types.Uint64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
|
|
return 0
|
|
|
|
# Monster
|
|
def VectorOfWeakReferencesAsNumpy(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(78))
|
|
if o != 0:
|
|
return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint64Flags, o)
|
|
return 0
|
|
|
|
# Monster
|
|
def VectorOfWeakReferencesLength(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(78))
|
|
if o != 0:
|
|
return self._tab.VectorLen(o)
|
|
return 0
|
|
|
|
# Monster
|
|
def VectorOfWeakReferencesIsNone(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(78))
|
|
return o == 0
|
|
|
|
# Monster
|
|
def VectorOfStrongReferrables(self, j):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(80))
|
|
if o != 0:
|
|
x = self._tab.Vector(o)
|
|
x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
|
|
x = self._tab.Indirect(x)
|
|
from MyGame.Example.Referrable import Referrable
|
|
obj = Referrable()
|
|
obj.Init(self._tab.Bytes, x)
|
|
return obj
|
|
return None
|
|
|
|
# Monster
|
|
def VectorOfStrongReferrablesLength(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(80))
|
|
if o != 0:
|
|
return self._tab.VectorLen(o)
|
|
return 0
|
|
|
|
# Monster
|
|
def VectorOfStrongReferrablesIsNone(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(80))
|
|
return o == 0
|
|
|
|
# Monster
|
|
def CoOwningReference(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(82))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
|
|
return 0
|
|
|
|
# Monster
|
|
def VectorOfCoOwningReferences(self, j):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(84))
|
|
if o != 0:
|
|
a = self._tab.Vector(o)
|
|
return self._tab.Get(flatbuffers.number_types.Uint64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
|
|
return 0
|
|
|
|
# Monster
|
|
def VectorOfCoOwningReferencesAsNumpy(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(84))
|
|
if o != 0:
|
|
return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint64Flags, o)
|
|
return 0
|
|
|
|
# Monster
|
|
def VectorOfCoOwningReferencesLength(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(84))
|
|
if o != 0:
|
|
return self._tab.VectorLen(o)
|
|
return 0
|
|
|
|
# Monster
|
|
def VectorOfCoOwningReferencesIsNone(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(84))
|
|
return o == 0
|
|
|
|
# Monster
|
|
def NonOwningReference(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(86))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
|
|
return 0
|
|
|
|
# Monster
|
|
def VectorOfNonOwningReferences(self, j):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
|
|
if o != 0:
|
|
a = self._tab.Vector(o)
|
|
return self._tab.Get(flatbuffers.number_types.Uint64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
|
|
return 0
|
|
|
|
# Monster
|
|
def VectorOfNonOwningReferencesAsNumpy(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
|
|
if o != 0:
|
|
return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint64Flags, o)
|
|
return 0
|
|
|
|
# Monster
|
|
def VectorOfNonOwningReferencesLength(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
|
|
if o != 0:
|
|
return self._tab.VectorLen(o)
|
|
return 0
|
|
|
|
# Monster
|
|
def VectorOfNonOwningReferencesIsNone(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
|
|
return o == 0
|
|
|
|
# Monster
|
|
def AnyUniqueType(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(90))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
|
|
return 0
|
|
|
|
# Monster
|
|
def AnyUnique(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(92))
|
|
if o != 0:
|
|
from flatbuffers.table import Table
|
|
obj = Table(bytearray(), 0)
|
|
self._tab.Union(obj, o)
|
|
return obj
|
|
return None
|
|
|
|
# Monster
|
|
def AnyAmbiguousType(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(94))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
|
|
return 0
|
|
|
|
# Monster
|
|
def AnyAmbiguous(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(96))
|
|
if o != 0:
|
|
from flatbuffers.table import Table
|
|
obj = Table(bytearray(), 0)
|
|
self._tab.Union(obj, o)
|
|
return obj
|
|
return None
|
|
|
|
# Monster
|
|
def VectorOfEnums(self, j):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
|
|
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
|
|
|
|
# Monster
|
|
def VectorOfEnumsAsNumpy(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
|
|
if o != 0:
|
|
return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
|
|
return 0
|
|
|
|
# Monster
|
|
def VectorOfEnumsLength(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
|
|
if o != 0:
|
|
return self._tab.VectorLen(o)
|
|
return 0
|
|
|
|
# Monster
|
|
def VectorOfEnumsIsNone(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
|
|
return o == 0
|
|
|
|
# Monster
|
|
def SignedEnum(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(100))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
|
|
return -1
|
|
|
|
# Monster
|
|
def Testrequirednestedflatbuffer(self, j):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
|
|
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
|
|
|
|
# Monster
|
|
def TestrequirednestedflatbufferAsNumpy(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
|
|
if o != 0:
|
|
return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
|
|
return 0
|
|
|
|
# Monster
|
|
def TestrequirednestedflatbufferNestedRoot(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
|
|
if o != 0:
|
|
from MyGame.Example.Monster import Monster
|
|
return Monster.GetRootAs(self._tab.Bytes, self._tab.Vector(o))
|
|
return 0
|
|
|
|
# Monster
|
|
def TestrequirednestedflatbufferLength(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
|
|
if o != 0:
|
|
return self._tab.VectorLen(o)
|
|
return 0
|
|
|
|
# Monster
|
|
def TestrequirednestedflatbufferIsNone(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
|
|
return o == 0
|
|
|
|
# Monster
|
|
def ScalarKeySortedTables(self, j):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(104))
|
|
if o != 0:
|
|
x = self._tab.Vector(o)
|
|
x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
|
|
x = self._tab.Indirect(x)
|
|
from MyGame.Example.Stat import Stat
|
|
obj = Stat()
|
|
obj.Init(self._tab.Bytes, x)
|
|
return obj
|
|
return None
|
|
|
|
# Monster
|
|
def ScalarKeySortedTablesLength(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(104))
|
|
if o != 0:
|
|
return self._tab.VectorLen(o)
|
|
return 0
|
|
|
|
# Monster
|
|
def ScalarKeySortedTablesIsNone(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(104))
|
|
return o == 0
|
|
|
|
def Start(builder): builder.StartObject(51)
|
|
def MonsterStart(builder):
|
|
"""This method is deprecated. Please switch to Start."""
|
|
return Start(builder)
|
|
def AddPos(builder, pos): builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pos), 0)
|
|
def MonsterAddPos(builder, pos):
|
|
"""This method is deprecated. Please switch to AddPos."""
|
|
return AddPos(builder, pos)
|
|
def AddMana(builder, mana): builder.PrependInt16Slot(1, mana, 150)
|
|
def MonsterAddMana(builder, mana):
|
|
"""This method is deprecated. Please switch to AddMana."""
|
|
return AddMana(builder, mana)
|
|
def AddHp(builder, hp): builder.PrependInt16Slot(2, hp, 100)
|
|
def MonsterAddHp(builder, hp):
|
|
"""This method is deprecated. Please switch to AddHp."""
|
|
return AddHp(builder, hp)
|
|
def AddName(builder, name): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
|
|
def MonsterAddName(builder, name):
|
|
"""This method is deprecated. Please switch to AddName."""
|
|
return AddName(builder, name)
|
|
def AddInventory(builder, inventory): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(inventory), 0)
|
|
def MonsterAddInventory(builder, inventory):
|
|
"""This method is deprecated. Please switch to AddInventory."""
|
|
return AddInventory(builder, inventory)
|
|
def StartInventoryVector(builder, numElems): return builder.StartVector(1, numElems, 1)
|
|
def MonsterStartInventoryVector(builder, numElems):
|
|
"""This method is deprecated. Please switch to Start."""
|
|
return StartInventoryVector(builder, numElems)
|
|
def AddColor(builder, color): builder.PrependUint8Slot(6, color, 8)
|
|
def MonsterAddColor(builder, color):
|
|
"""This method is deprecated. Please switch to AddColor."""
|
|
return AddColor(builder, color)
|
|
def AddTestType(builder, testType): builder.PrependUint8Slot(7, testType, 0)
|
|
def MonsterAddTestType(builder, testType):
|
|
"""This method is deprecated. Please switch to AddTestType."""
|
|
return AddTestType(builder, testType)
|
|
def AddTest(builder, test): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(test), 0)
|
|
def MonsterAddTest(builder, test):
|
|
"""This method is deprecated. Please switch to AddTest."""
|
|
return AddTest(builder, test)
|
|
def AddTest4(builder, test4): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(test4), 0)
|
|
def MonsterAddTest4(builder, test4):
|
|
"""This method is deprecated. Please switch to AddTest4."""
|
|
return AddTest4(builder, test4)
|
|
def StartTest4Vector(builder, numElems): return builder.StartVector(4, numElems, 2)
|
|
def MonsterStartTest4Vector(builder, numElems):
|
|
"""This method is deprecated. Please switch to Start."""
|
|
return StartTest4Vector(builder, numElems)
|
|
def AddTestarrayofstring(builder, testarrayofstring): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring), 0)
|
|
def MonsterAddTestarrayofstring(builder, testarrayofstring):
|
|
"""This method is deprecated. Please switch to AddTestarrayofstring."""
|
|
return AddTestarrayofstring(builder, testarrayofstring)
|
|
def StartTestarrayofstringVector(builder, numElems): return builder.StartVector(4, numElems, 4)
|
|
def MonsterStartTestarrayofstringVector(builder, numElems):
|
|
"""This method is deprecated. Please switch to Start."""
|
|
return StartTestarrayofstringVector(builder, numElems)
|
|
def AddTestarrayoftables(builder, testarrayoftables): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayoftables), 0)
|
|
def MonsterAddTestarrayoftables(builder, testarrayoftables):
|
|
"""This method is deprecated. Please switch to AddTestarrayoftables."""
|
|
return AddTestarrayoftables(builder, testarrayoftables)
|
|
def StartTestarrayoftablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
|
|
def MonsterStartTestarrayoftablesVector(builder, numElems):
|
|
"""This method is deprecated. Please switch to Start."""
|
|
return StartTestarrayoftablesVector(builder, numElems)
|
|
def AddEnemy(builder, enemy): builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(enemy), 0)
|
|
def MonsterAddEnemy(builder, enemy):
|
|
"""This method is deprecated. Please switch to AddEnemy."""
|
|
return AddEnemy(builder, enemy)
|
|
def AddTestnestedflatbuffer(builder, testnestedflatbuffer): builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(testnestedflatbuffer), 0)
|
|
def MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer):
|
|
"""This method is deprecated. Please switch to AddTestnestedflatbuffer."""
|
|
return AddTestnestedflatbuffer(builder, testnestedflatbuffer)
|
|
def StartTestnestedflatbufferVector(builder, numElems): return builder.StartVector(1, numElems, 1)
|
|
def MonsterStartTestnestedflatbufferVector(builder, numElems):
|
|
"""This method is deprecated. Please switch to Start."""
|
|
return StartTestnestedflatbufferVector(builder, numElems)
|
|
def MakeVectorFromBytes(builder, bytes):
|
|
builder.StartVector(1, len(bytes), 1)
|
|
builder.head = builder.head - len(bytes)
|
|
builder.Bytes[builder.head : builder.head + len(bytes)] = bytes
|
|
return builder.EndVector()
|
|
def MakeTestnestedflatbufferVectorFromBytes(builder, bytes):
|
|
builder.StartVector(1, len(bytes), 1)
|
|
builder.head = builder.head - len(bytes)
|
|
builder.Bytes[builder.head : builder.head + len(bytes)] = bytes
|
|
return builder.EndVector()
|
|
def AddTestempty(builder, testempty): builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(testempty), 0)
|
|
def MonsterAddTestempty(builder, testempty):
|
|
"""This method is deprecated. Please switch to AddTestempty."""
|
|
return AddTestempty(builder, testempty)
|
|
def AddTestbool(builder, testbool): builder.PrependBoolSlot(15, testbool, 0)
|
|
def MonsterAddTestbool(builder, testbool):
|
|
"""This method is deprecated. Please switch to AddTestbool."""
|
|
return AddTestbool(builder, testbool)
|
|
def AddTesthashs32Fnv1(builder, testhashs32Fnv1): builder.PrependInt32Slot(16, testhashs32Fnv1, 0)
|
|
def MonsterAddTesthashs32Fnv1(builder, testhashs32Fnv1):
|
|
"""This method is deprecated. Please switch to AddTesthashs32Fnv1."""
|
|
return AddTesthashs32Fnv1(builder, testhashs32Fnv1)
|
|
def AddTesthashu32Fnv1(builder, testhashu32Fnv1): builder.PrependUint32Slot(17, testhashu32Fnv1, 0)
|
|
def MonsterAddTesthashu32Fnv1(builder, testhashu32Fnv1):
|
|
"""This method is deprecated. Please switch to AddTesthashu32Fnv1."""
|
|
return AddTesthashu32Fnv1(builder, testhashu32Fnv1)
|
|
def AddTesthashs64Fnv1(builder, testhashs64Fnv1): builder.PrependInt64Slot(18, testhashs64Fnv1, 0)
|
|
def MonsterAddTesthashs64Fnv1(builder, testhashs64Fnv1):
|
|
"""This method is deprecated. Please switch to AddTesthashs64Fnv1."""
|
|
return AddTesthashs64Fnv1(builder, testhashs64Fnv1)
|
|
def AddTesthashu64Fnv1(builder, testhashu64Fnv1): builder.PrependUint64Slot(19, testhashu64Fnv1, 0)
|
|
def MonsterAddTesthashu64Fnv1(builder, testhashu64Fnv1):
|
|
"""This method is deprecated. Please switch to AddTesthashu64Fnv1."""
|
|
return AddTesthashu64Fnv1(builder, testhashu64Fnv1)
|
|
def AddTesthashs32Fnv1a(builder, testhashs32Fnv1a): builder.PrependInt32Slot(20, testhashs32Fnv1a, 0)
|
|
def MonsterAddTesthashs32Fnv1a(builder, testhashs32Fnv1a):
|
|
"""This method is deprecated. Please switch to AddTesthashs32Fnv1a."""
|
|
return AddTesthashs32Fnv1a(builder, testhashs32Fnv1a)
|
|
def AddTesthashu32Fnv1a(builder, testhashu32Fnv1a): builder.PrependUint32Slot(21, testhashu32Fnv1a, 0)
|
|
def MonsterAddTesthashu32Fnv1a(builder, testhashu32Fnv1a):
|
|
"""This method is deprecated. Please switch to AddTesthashu32Fnv1a."""
|
|
return AddTesthashu32Fnv1a(builder, testhashu32Fnv1a)
|
|
def AddTesthashs64Fnv1a(builder, testhashs64Fnv1a): builder.PrependInt64Slot(22, testhashs64Fnv1a, 0)
|
|
def MonsterAddTesthashs64Fnv1a(builder, testhashs64Fnv1a):
|
|
"""This method is deprecated. Please switch to AddTesthashs64Fnv1a."""
|
|
return AddTesthashs64Fnv1a(builder, testhashs64Fnv1a)
|
|
def AddTesthashu64Fnv1a(builder, testhashu64Fnv1a): builder.PrependUint64Slot(23, testhashu64Fnv1a, 0)
|
|
def MonsterAddTesthashu64Fnv1a(builder, testhashu64Fnv1a):
|
|
"""This method is deprecated. Please switch to AddTesthashu64Fnv1a."""
|
|
return AddTesthashu64Fnv1a(builder, testhashu64Fnv1a)
|
|
def AddTestarrayofbools(builder, testarrayofbools): builder.PrependUOffsetTRelativeSlot(24, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofbools), 0)
|
|
def MonsterAddTestarrayofbools(builder, testarrayofbools):
|
|
"""This method is deprecated. Please switch to AddTestarrayofbools."""
|
|
return AddTestarrayofbools(builder, testarrayofbools)
|
|
def StartTestarrayofboolsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
|
|
def MonsterStartTestarrayofboolsVector(builder, numElems):
|
|
"""This method is deprecated. Please switch to Start."""
|
|
return StartTestarrayofboolsVector(builder, numElems)
|
|
def AddTestf(builder, testf): builder.PrependFloat32Slot(25, testf, 3.14159)
|
|
def MonsterAddTestf(builder, testf):
|
|
"""This method is deprecated. Please switch to AddTestf."""
|
|
return AddTestf(builder, testf)
|
|
def AddTestf2(builder, testf2): builder.PrependFloat32Slot(26, testf2, 3.0)
|
|
def MonsterAddTestf2(builder, testf2):
|
|
"""This method is deprecated. Please switch to AddTestf2."""
|
|
return AddTestf2(builder, testf2)
|
|
def AddTestf3(builder, testf3): builder.PrependFloat32Slot(27, testf3, 0.0)
|
|
def MonsterAddTestf3(builder, testf3):
|
|
"""This method is deprecated. Please switch to AddTestf3."""
|
|
return AddTestf3(builder, testf3)
|
|
def AddTestarrayofstring2(builder, testarrayofstring2): builder.PrependUOffsetTRelativeSlot(28, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring2), 0)
|
|
def MonsterAddTestarrayofstring2(builder, testarrayofstring2):
|
|
"""This method is deprecated. Please switch to AddTestarrayofstring2."""
|
|
return AddTestarrayofstring2(builder, testarrayofstring2)
|
|
def StartTestarrayofstring2Vector(builder, numElems): return builder.StartVector(4, numElems, 4)
|
|
def MonsterStartTestarrayofstring2Vector(builder, numElems):
|
|
"""This method is deprecated. Please switch to Start."""
|
|
return StartTestarrayofstring2Vector(builder, numElems)
|
|
def AddTestarrayofsortedstruct(builder, testarrayofsortedstruct): builder.PrependUOffsetTRelativeSlot(29, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofsortedstruct), 0)
|
|
def MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct):
|
|
"""This method is deprecated. Please switch to AddTestarrayofsortedstruct."""
|
|
return AddTestarrayofsortedstruct(builder, testarrayofsortedstruct)
|
|
def StartTestarrayofsortedstructVector(builder, numElems): return builder.StartVector(8, numElems, 4)
|
|
def MonsterStartTestarrayofsortedstructVector(builder, numElems):
|
|
"""This method is deprecated. Please switch to Start."""
|
|
return StartTestarrayofsortedstructVector(builder, numElems)
|
|
def AddFlex(builder, flex): builder.PrependUOffsetTRelativeSlot(30, flatbuffers.number_types.UOffsetTFlags.py_type(flex), 0)
|
|
def MonsterAddFlex(builder, flex):
|
|
"""This method is deprecated. Please switch to AddFlex."""
|
|
return AddFlex(builder, flex)
|
|
def StartFlexVector(builder, numElems): return builder.StartVector(1, numElems, 1)
|
|
def MonsterStartFlexVector(builder, numElems):
|
|
"""This method is deprecated. Please switch to Start."""
|
|
return StartFlexVector(builder, numElems)
|
|
def AddTest5(builder, test5): builder.PrependUOffsetTRelativeSlot(31, flatbuffers.number_types.UOffsetTFlags.py_type(test5), 0)
|
|
def MonsterAddTest5(builder, test5):
|
|
"""This method is deprecated. Please switch to AddTest5."""
|
|
return AddTest5(builder, test5)
|
|
def StartTest5Vector(builder, numElems): return builder.StartVector(4, numElems, 2)
|
|
def MonsterStartTest5Vector(builder, numElems):
|
|
"""This method is deprecated. Please switch to Start."""
|
|
return StartTest5Vector(builder, numElems)
|
|
def AddVectorOfLongs(builder, vectorOfLongs): builder.PrependUOffsetTRelativeSlot(32, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfLongs), 0)
|
|
def MonsterAddVectorOfLongs(builder, vectorOfLongs):
|
|
"""This method is deprecated. Please switch to AddVectorOfLongs."""
|
|
return AddVectorOfLongs(builder, vectorOfLongs)
|
|
def StartVectorOfLongsVector(builder, numElems): return builder.StartVector(8, numElems, 8)
|
|
def MonsterStartVectorOfLongsVector(builder, numElems):
|
|
"""This method is deprecated. Please switch to Start."""
|
|
return StartVectorOfLongsVector(builder, numElems)
|
|
def AddVectorOfDoubles(builder, vectorOfDoubles): builder.PrependUOffsetTRelativeSlot(33, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfDoubles), 0)
|
|
def MonsterAddVectorOfDoubles(builder, vectorOfDoubles):
|
|
"""This method is deprecated. Please switch to AddVectorOfDoubles."""
|
|
return AddVectorOfDoubles(builder, vectorOfDoubles)
|
|
def StartVectorOfDoublesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
|
|
def MonsterStartVectorOfDoublesVector(builder, numElems):
|
|
"""This method is deprecated. Please switch to Start."""
|
|
return StartVectorOfDoublesVector(builder, numElems)
|
|
def AddParentNamespaceTest(builder, parentNamespaceTest): builder.PrependUOffsetTRelativeSlot(34, flatbuffers.number_types.UOffsetTFlags.py_type(parentNamespaceTest), 0)
|
|
def MonsterAddParentNamespaceTest(builder, parentNamespaceTest):
|
|
"""This method is deprecated. Please switch to AddParentNamespaceTest."""
|
|
return AddParentNamespaceTest(builder, parentNamespaceTest)
|
|
def AddVectorOfReferrables(builder, vectorOfReferrables): builder.PrependUOffsetTRelativeSlot(35, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfReferrables), 0)
|
|
def MonsterAddVectorOfReferrables(builder, vectorOfReferrables):
|
|
"""This method is deprecated. Please switch to AddVectorOfReferrables."""
|
|
return AddVectorOfReferrables(builder, vectorOfReferrables)
|
|
def StartVectorOfReferrablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
|
|
def MonsterStartVectorOfReferrablesVector(builder, numElems):
|
|
"""This method is deprecated. Please switch to Start."""
|
|
return StartVectorOfReferrablesVector(builder, numElems)
|
|
def AddSingleWeakReference(builder, singleWeakReference): builder.PrependUint64Slot(36, singleWeakReference, 0)
|
|
def MonsterAddSingleWeakReference(builder, singleWeakReference):
|
|
"""This method is deprecated. Please switch to AddSingleWeakReference."""
|
|
return AddSingleWeakReference(builder, singleWeakReference)
|
|
def AddVectorOfWeakReferences(builder, vectorOfWeakReferences): builder.PrependUOffsetTRelativeSlot(37, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfWeakReferences), 0)
|
|
def MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences):
|
|
"""This method is deprecated. Please switch to AddVectorOfWeakReferences."""
|
|
return AddVectorOfWeakReferences(builder, vectorOfWeakReferences)
|
|
def StartVectorOfWeakReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
|
|
def MonsterStartVectorOfWeakReferencesVector(builder, numElems):
|
|
"""This method is deprecated. Please switch to Start."""
|
|
return StartVectorOfWeakReferencesVector(builder, numElems)
|
|
def AddVectorOfStrongReferrables(builder, vectorOfStrongReferrables): builder.PrependUOffsetTRelativeSlot(38, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfStrongReferrables), 0)
|
|
def MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables):
|
|
"""This method is deprecated. Please switch to AddVectorOfStrongReferrables."""
|
|
return AddVectorOfStrongReferrables(builder, vectorOfStrongReferrables)
|
|
def StartVectorOfStrongReferrablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
|
|
def MonsterStartVectorOfStrongReferrablesVector(builder, numElems):
|
|
"""This method is deprecated. Please switch to Start."""
|
|
return StartVectorOfStrongReferrablesVector(builder, numElems)
|
|
def AddCoOwningReference(builder, coOwningReference): builder.PrependUint64Slot(39, coOwningReference, 0)
|
|
def MonsterAddCoOwningReference(builder, coOwningReference):
|
|
"""This method is deprecated. Please switch to AddCoOwningReference."""
|
|
return AddCoOwningReference(builder, coOwningReference)
|
|
def AddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences): builder.PrependUOffsetTRelativeSlot(40, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfCoOwningReferences), 0)
|
|
def MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences):
|
|
"""This method is deprecated. Please switch to AddVectorOfCoOwningReferences."""
|
|
return AddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences)
|
|
def StartVectorOfCoOwningReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
|
|
def MonsterStartVectorOfCoOwningReferencesVector(builder, numElems):
|
|
"""This method is deprecated. Please switch to Start."""
|
|
return StartVectorOfCoOwningReferencesVector(builder, numElems)
|
|
def AddNonOwningReference(builder, nonOwningReference): builder.PrependUint64Slot(41, nonOwningReference, 0)
|
|
def MonsterAddNonOwningReference(builder, nonOwningReference):
|
|
"""This method is deprecated. Please switch to AddNonOwningReference."""
|
|
return AddNonOwningReference(builder, nonOwningReference)
|
|
def AddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences): builder.PrependUOffsetTRelativeSlot(42, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfNonOwningReferences), 0)
|
|
def MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences):
|
|
"""This method is deprecated. Please switch to AddVectorOfNonOwningReferences."""
|
|
return AddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences)
|
|
def StartVectorOfNonOwningReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
|
|
def MonsterStartVectorOfNonOwningReferencesVector(builder, numElems):
|
|
"""This method is deprecated. Please switch to Start."""
|
|
return StartVectorOfNonOwningReferencesVector(builder, numElems)
|
|
def AddAnyUniqueType(builder, anyUniqueType): builder.PrependUint8Slot(43, anyUniqueType, 0)
|
|
def MonsterAddAnyUniqueType(builder, anyUniqueType):
|
|
"""This method is deprecated. Please switch to AddAnyUniqueType."""
|
|
return AddAnyUniqueType(builder, anyUniqueType)
|
|
def AddAnyUnique(builder, anyUnique): builder.PrependUOffsetTRelativeSlot(44, flatbuffers.number_types.UOffsetTFlags.py_type(anyUnique), 0)
|
|
def MonsterAddAnyUnique(builder, anyUnique):
|
|
"""This method is deprecated. Please switch to AddAnyUnique."""
|
|
return AddAnyUnique(builder, anyUnique)
|
|
def AddAnyAmbiguousType(builder, anyAmbiguousType): builder.PrependUint8Slot(45, anyAmbiguousType, 0)
|
|
def MonsterAddAnyAmbiguousType(builder, anyAmbiguousType):
|
|
"""This method is deprecated. Please switch to AddAnyAmbiguousType."""
|
|
return AddAnyAmbiguousType(builder, anyAmbiguousType)
|
|
def AddAnyAmbiguous(builder, anyAmbiguous): builder.PrependUOffsetTRelativeSlot(46, flatbuffers.number_types.UOffsetTFlags.py_type(anyAmbiguous), 0)
|
|
def MonsterAddAnyAmbiguous(builder, anyAmbiguous):
|
|
"""This method is deprecated. Please switch to AddAnyAmbiguous."""
|
|
return AddAnyAmbiguous(builder, anyAmbiguous)
|
|
def AddVectorOfEnums(builder, vectorOfEnums): builder.PrependUOffsetTRelativeSlot(47, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfEnums), 0)
|
|
def MonsterAddVectorOfEnums(builder, vectorOfEnums):
|
|
"""This method is deprecated. Please switch to AddVectorOfEnums."""
|
|
return AddVectorOfEnums(builder, vectorOfEnums)
|
|
def StartVectorOfEnumsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
|
|
def MonsterStartVectorOfEnumsVector(builder, numElems):
|
|
"""This method is deprecated. Please switch to Start."""
|
|
return StartVectorOfEnumsVector(builder, numElems)
|
|
def AddSignedEnum(builder, signedEnum): builder.PrependInt8Slot(48, signedEnum, -1)
|
|
def MonsterAddSignedEnum(builder, signedEnum):
|
|
"""This method is deprecated. Please switch to AddSignedEnum."""
|
|
return AddSignedEnum(builder, signedEnum)
|
|
def AddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer): builder.PrependUOffsetTRelativeSlot(49, flatbuffers.number_types.UOffsetTFlags.py_type(testrequirednestedflatbuffer), 0)
|
|
def MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer):
|
|
"""This method is deprecated. Please switch to AddTestrequirednestedflatbuffer."""
|
|
return AddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer)
|
|
def StartTestrequirednestedflatbufferVector(builder, numElems): return builder.StartVector(1, numElems, 1)
|
|
def MonsterStartTestrequirednestedflatbufferVector(builder, numElems):
|
|
"""This method is deprecated. Please switch to Start."""
|
|
return StartTestrequirednestedflatbufferVector(builder, numElems)
|
|
def MakeVectorFromBytes(builder, bytes):
|
|
builder.StartVector(1, len(bytes), 1)
|
|
builder.head = builder.head - len(bytes)
|
|
builder.Bytes[builder.head : builder.head + len(bytes)] = bytes
|
|
return builder.EndVector()
|
|
def MakeTestrequirednestedflatbufferVectorFromBytes(builder, bytes):
|
|
builder.StartVector(1, len(bytes), 1)
|
|
builder.head = builder.head - len(bytes)
|
|
builder.Bytes[builder.head : builder.head + len(bytes)] = bytes
|
|
return builder.EndVector()
|
|
def AddScalarKeySortedTables(builder, scalarKeySortedTables): builder.PrependUOffsetTRelativeSlot(50, flatbuffers.number_types.UOffsetTFlags.py_type(scalarKeySortedTables), 0)
|
|
def MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables):
|
|
"""This method is deprecated. Please switch to AddScalarKeySortedTables."""
|
|
return AddScalarKeySortedTables(builder, scalarKeySortedTables)
|
|
def StartScalarKeySortedTablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
|
|
def MonsterStartScalarKeySortedTablesVector(builder, numElems):
|
|
"""This method is deprecated. Please switch to Start."""
|
|
return StartScalarKeySortedTablesVector(builder, numElems)
|
|
def End(builder): return builder.EndObject()
|
|
def MonsterEnd(builder):
|
|
"""This method is deprecated. Please switch to End."""
|
|
return End(builder)
|
|
import MyGame.Example.Ability
|
|
import MyGame.Example.Any
|
|
import MyGame.Example.AnyAmbiguousAliases
|
|
import MyGame.Example.AnyUniqueAliases
|
|
import MyGame.Example.Referrable
|
|
import MyGame.Example.Stat
|
|
import MyGame.Example.Test
|
|
import MyGame.Example.TestSimpleTableWithEnum
|
|
import MyGame.Example.Vec3
|
|
import MyGame.Example2.Monster
|
|
import MyGame.InParentNamespace
|
|
try:
|
|
from typing import List, Optional, Union
|
|
except:
|
|
pass
|
|
|
|
class MonsterT(object):
|
|
|
|
# MonsterT
|
|
def __init__(self):
|
|
self.pos = None # type: Optional[MyGame.Example.Vec3.Vec3T]
|
|
self.mana = 150 # type: int
|
|
self.hp = 100 # type: int
|
|
self.name = None # type: str
|
|
self.inventory = None # type: List[int]
|
|
self.color = 8 # type: int
|
|
self.testType = 0 # type: int
|
|
self.test = None # type: Union[None, MyGame.Example.Monster.MonsterT, MyGame.Example.TestSimpleTableWithEnum.TestSimpleTableWithEnumT, MyGame.Example2.Monster.MonsterT]
|
|
self.test4 = None # type: List[MyGame.Example.Test.TestT]
|
|
self.testarrayofstring = None # type: List[str]
|
|
self.testarrayoftables = None # type: List[MyGame.Example.Monster.MonsterT]
|
|
self.enemy = None # type: Optional[MyGame.Example.Monster.MonsterT]
|
|
self.testnestedflatbuffer = None # type: List[int]
|
|
self.testempty = None # type: Optional[MyGame.Example.Stat.StatT]
|
|
self.testbool = False # type: bool
|
|
self.testhashs32Fnv1 = 0 # type: int
|
|
self.testhashu32Fnv1 = 0 # type: int
|
|
self.testhashs64Fnv1 = 0 # type: int
|
|
self.testhashu64Fnv1 = 0 # type: int
|
|
self.testhashs32Fnv1a = 0 # type: int
|
|
self.testhashu32Fnv1a = 0 # type: int
|
|
self.testhashs64Fnv1a = 0 # type: int
|
|
self.testhashu64Fnv1a = 0 # type: int
|
|
self.testarrayofbools = None # type: List[bool]
|
|
self.testf = 3.14159 # type: float
|
|
self.testf2 = 3.0 # type: float
|
|
self.testf3 = 0.0 # type: float
|
|
self.testarrayofstring2 = None # type: List[str]
|
|
self.testarrayofsortedstruct = None # type: List[MyGame.Example.Ability.AbilityT]
|
|
self.flex = None # type: List[int]
|
|
self.test5 = None # type: List[MyGame.Example.Test.TestT]
|
|
self.vectorOfLongs = None # type: List[int]
|
|
self.vectorOfDoubles = None # type: List[float]
|
|
self.parentNamespaceTest = None # type: Optional[MyGame.InParentNamespace.InParentNamespaceT]
|
|
self.vectorOfReferrables = None # type: List[MyGame.Example.Referrable.ReferrableT]
|
|
self.singleWeakReference = 0 # type: int
|
|
self.vectorOfWeakReferences = None # type: List[int]
|
|
self.vectorOfStrongReferrables = None # type: List[MyGame.Example.Referrable.ReferrableT]
|
|
self.coOwningReference = 0 # type: int
|
|
self.vectorOfCoOwningReferences = None # type: List[int]
|
|
self.nonOwningReference = 0 # type: int
|
|
self.vectorOfNonOwningReferences = None # type: List[int]
|
|
self.anyUniqueType = 0 # type: int
|
|
self.anyUnique = None # type: Union[None, MyGame.Example.Monster.MonsterT, MyGame.Example.TestSimpleTableWithEnum.TestSimpleTableWithEnumT, MyGame.Example2.Monster.MonsterT]
|
|
self.anyAmbiguousType = 0 # type: int
|
|
self.anyAmbiguous = None # type: Union[None, MyGame.Example.Monster.MonsterT, MyGame.Example.Monster.MonsterT, MyGame.Example.Monster.MonsterT]
|
|
self.vectorOfEnums = None # type: List[int]
|
|
self.signedEnum = -1 # type: int
|
|
self.testrequirednestedflatbuffer = None # type: List[int]
|
|
self.scalarKeySortedTables = None # type: List[MyGame.Example.Stat.StatT]
|
|
|
|
@classmethod
|
|
def InitFromBuf(cls, buf, pos):
|
|
monster = Monster()
|
|
monster.Init(buf, pos)
|
|
return cls.InitFromObj(monster)
|
|
|
|
@classmethod
|
|
def InitFromObj(cls, monster):
|
|
x = MonsterT()
|
|
x._UnPack(monster)
|
|
return x
|
|
|
|
# MonsterT
|
|
def _UnPack(self, monster):
|
|
if monster is None:
|
|
return
|
|
if monster.Pos() is not None:
|
|
self.pos = MyGame.Example.Vec3.Vec3T.InitFromObj(monster.Pos())
|
|
self.mana = monster.Mana()
|
|
self.hp = monster.Hp()
|
|
self.name = monster.Name()
|
|
if not monster.InventoryIsNone():
|
|
if np is None:
|
|
self.inventory = []
|
|
for i in range(monster.InventoryLength()):
|
|
self.inventory.append(monster.Inventory(i))
|
|
else:
|
|
self.inventory = monster.InventoryAsNumpy()
|
|
self.color = monster.Color()
|
|
self.testType = monster.TestType()
|
|
self.test = MyGame.Example.Any.AnyCreator(self.testType, monster.Test())
|
|
if not monster.Test4IsNone():
|
|
self.test4 = []
|
|
for i in range(monster.Test4Length()):
|
|
if monster.Test4(i) is None:
|
|
self.test4.append(None)
|
|
else:
|
|
test_ = MyGame.Example.Test.TestT.InitFromObj(monster.Test4(i))
|
|
self.test4.append(test_)
|
|
if not monster.TestarrayofstringIsNone():
|
|
self.testarrayofstring = []
|
|
for i in range(monster.TestarrayofstringLength()):
|
|
self.testarrayofstring.append(monster.Testarrayofstring(i))
|
|
if not monster.TestarrayoftablesIsNone():
|
|
self.testarrayoftables = []
|
|
for i in range(monster.TestarrayoftablesLength()):
|
|
if monster.Testarrayoftables(i) is None:
|
|
self.testarrayoftables.append(None)
|
|
else:
|
|
monster_ = MyGame.Example.Monster.MonsterT.InitFromObj(monster.Testarrayoftables(i))
|
|
self.testarrayoftables.append(monster_)
|
|
if monster.Enemy() is not None:
|
|
self.enemy = MyGame.Example.Monster.MonsterT.InitFromObj(monster.Enemy())
|
|
if not monster.TestnestedflatbufferIsNone():
|
|
if np is None:
|
|
self.testnestedflatbuffer = []
|
|
for i in range(monster.TestnestedflatbufferLength()):
|
|
self.testnestedflatbuffer.append(monster.Testnestedflatbuffer(i))
|
|
else:
|
|
self.testnestedflatbuffer = monster.TestnestedflatbufferAsNumpy()
|
|
if monster.Testempty() is not None:
|
|
self.testempty = MyGame.Example.Stat.StatT.InitFromObj(monster.Testempty())
|
|
self.testbool = monster.Testbool()
|
|
self.testhashs32Fnv1 = monster.Testhashs32Fnv1()
|
|
self.testhashu32Fnv1 = monster.Testhashu32Fnv1()
|
|
self.testhashs64Fnv1 = monster.Testhashs64Fnv1()
|
|
self.testhashu64Fnv1 = monster.Testhashu64Fnv1()
|
|
self.testhashs32Fnv1a = monster.Testhashs32Fnv1a()
|
|
self.testhashu32Fnv1a = monster.Testhashu32Fnv1a()
|
|
self.testhashs64Fnv1a = monster.Testhashs64Fnv1a()
|
|
self.testhashu64Fnv1a = monster.Testhashu64Fnv1a()
|
|
if not monster.TestarrayofboolsIsNone():
|
|
if np is None:
|
|
self.testarrayofbools = []
|
|
for i in range(monster.TestarrayofboolsLength()):
|
|
self.testarrayofbools.append(monster.Testarrayofbools(i))
|
|
else:
|
|
self.testarrayofbools = monster.TestarrayofboolsAsNumpy()
|
|
self.testf = monster.Testf()
|
|
self.testf2 = monster.Testf2()
|
|
self.testf3 = monster.Testf3()
|
|
if not monster.Testarrayofstring2IsNone():
|
|
self.testarrayofstring2 = []
|
|
for i in range(monster.Testarrayofstring2Length()):
|
|
self.testarrayofstring2.append(monster.Testarrayofstring2(i))
|
|
if not monster.TestarrayofsortedstructIsNone():
|
|
self.testarrayofsortedstruct = []
|
|
for i in range(monster.TestarrayofsortedstructLength()):
|
|
if monster.Testarrayofsortedstruct(i) is None:
|
|
self.testarrayofsortedstruct.append(None)
|
|
else:
|
|
ability_ = MyGame.Example.Ability.AbilityT.InitFromObj(monster.Testarrayofsortedstruct(i))
|
|
self.testarrayofsortedstruct.append(ability_)
|
|
if not monster.FlexIsNone():
|
|
if np is None:
|
|
self.flex = []
|
|
for i in range(monster.FlexLength()):
|
|
self.flex.append(monster.Flex(i))
|
|
else:
|
|
self.flex = monster.FlexAsNumpy()
|
|
if not monster.Test5IsNone():
|
|
self.test5 = []
|
|
for i in range(monster.Test5Length()):
|
|
if monster.Test5(i) is None:
|
|
self.test5.append(None)
|
|
else:
|
|
test_ = MyGame.Example.Test.TestT.InitFromObj(monster.Test5(i))
|
|
self.test5.append(test_)
|
|
if not monster.VectorOfLongsIsNone():
|
|
if np is None:
|
|
self.vectorOfLongs = []
|
|
for i in range(monster.VectorOfLongsLength()):
|
|
self.vectorOfLongs.append(monster.VectorOfLongs(i))
|
|
else:
|
|
self.vectorOfLongs = monster.VectorOfLongsAsNumpy()
|
|
if not monster.VectorOfDoublesIsNone():
|
|
if np is None:
|
|
self.vectorOfDoubles = []
|
|
for i in range(monster.VectorOfDoublesLength()):
|
|
self.vectorOfDoubles.append(monster.VectorOfDoubles(i))
|
|
else:
|
|
self.vectorOfDoubles = monster.VectorOfDoublesAsNumpy()
|
|
if monster.ParentNamespaceTest() is not None:
|
|
self.parentNamespaceTest = MyGame.InParentNamespace.InParentNamespaceT.InitFromObj(monster.ParentNamespaceTest())
|
|
if not monster.VectorOfReferrablesIsNone():
|
|
self.vectorOfReferrables = []
|
|
for i in range(monster.VectorOfReferrablesLength()):
|
|
if monster.VectorOfReferrables(i) is None:
|
|
self.vectorOfReferrables.append(None)
|
|
else:
|
|
referrable_ = MyGame.Example.Referrable.ReferrableT.InitFromObj(monster.VectorOfReferrables(i))
|
|
self.vectorOfReferrables.append(referrable_)
|
|
self.singleWeakReference = monster.SingleWeakReference()
|
|
if not monster.VectorOfWeakReferencesIsNone():
|
|
if np is None:
|
|
self.vectorOfWeakReferences = []
|
|
for i in range(monster.VectorOfWeakReferencesLength()):
|
|
self.vectorOfWeakReferences.append(monster.VectorOfWeakReferences(i))
|
|
else:
|
|
self.vectorOfWeakReferences = monster.VectorOfWeakReferencesAsNumpy()
|
|
if not monster.VectorOfStrongReferrablesIsNone():
|
|
self.vectorOfStrongReferrables = []
|
|
for i in range(monster.VectorOfStrongReferrablesLength()):
|
|
if monster.VectorOfStrongReferrables(i) is None:
|
|
self.vectorOfStrongReferrables.append(None)
|
|
else:
|
|
referrable_ = MyGame.Example.Referrable.ReferrableT.InitFromObj(monster.VectorOfStrongReferrables(i))
|
|
self.vectorOfStrongReferrables.append(referrable_)
|
|
self.coOwningReference = monster.CoOwningReference()
|
|
if not monster.VectorOfCoOwningReferencesIsNone():
|
|
if np is None:
|
|
self.vectorOfCoOwningReferences = []
|
|
for i in range(monster.VectorOfCoOwningReferencesLength()):
|
|
self.vectorOfCoOwningReferences.append(monster.VectorOfCoOwningReferences(i))
|
|
else:
|
|
self.vectorOfCoOwningReferences = monster.VectorOfCoOwningReferencesAsNumpy()
|
|
self.nonOwningReference = monster.NonOwningReference()
|
|
if not monster.VectorOfNonOwningReferencesIsNone():
|
|
if np is None:
|
|
self.vectorOfNonOwningReferences = []
|
|
for i in range(monster.VectorOfNonOwningReferencesLength()):
|
|
self.vectorOfNonOwningReferences.append(monster.VectorOfNonOwningReferences(i))
|
|
else:
|
|
self.vectorOfNonOwningReferences = monster.VectorOfNonOwningReferencesAsNumpy()
|
|
self.anyUniqueType = monster.AnyUniqueType()
|
|
self.anyUnique = MyGame.Example.AnyUniqueAliases.AnyUniqueAliasesCreator(self.anyUniqueType, monster.AnyUnique())
|
|
self.anyAmbiguousType = monster.AnyAmbiguousType()
|
|
self.anyAmbiguous = MyGame.Example.AnyAmbiguousAliases.AnyAmbiguousAliasesCreator(self.anyAmbiguousType, monster.AnyAmbiguous())
|
|
if not monster.VectorOfEnumsIsNone():
|
|
if np is None:
|
|
self.vectorOfEnums = []
|
|
for i in range(monster.VectorOfEnumsLength()):
|
|
self.vectorOfEnums.append(monster.VectorOfEnums(i))
|
|
else:
|
|
self.vectorOfEnums = monster.VectorOfEnumsAsNumpy()
|
|
self.signedEnum = monster.SignedEnum()
|
|
if not monster.TestrequirednestedflatbufferIsNone():
|
|
if np is None:
|
|
self.testrequirednestedflatbuffer = []
|
|
for i in range(monster.TestrequirednestedflatbufferLength()):
|
|
self.testrequirednestedflatbuffer.append(monster.Testrequirednestedflatbuffer(i))
|
|
else:
|
|
self.testrequirednestedflatbuffer = monster.TestrequirednestedflatbufferAsNumpy()
|
|
if not monster.ScalarKeySortedTablesIsNone():
|
|
self.scalarKeySortedTables = []
|
|
for i in range(monster.ScalarKeySortedTablesLength()):
|
|
if monster.ScalarKeySortedTables(i) is None:
|
|
self.scalarKeySortedTables.append(None)
|
|
else:
|
|
stat_ = MyGame.Example.Stat.StatT.InitFromObj(monster.ScalarKeySortedTables(i))
|
|
self.scalarKeySortedTables.append(stat_)
|
|
|
|
# MonsterT
|
|
def Pack(self, builder):
|
|
if self.name is not None:
|
|
name = builder.CreateString(self.name)
|
|
if self.inventory is not None:
|
|
if np is not None and type(self.inventory) is np.ndarray:
|
|
inventory = builder.CreateNumpyVector(self.inventory)
|
|
else:
|
|
StartInventoryVector(builder, len(self.inventory))
|
|
for i in reversed(range(len(self.inventory))):
|
|
builder.PrependUint8(self.inventory[i])
|
|
inventory = builder.EndVector()
|
|
if self.test is not None:
|
|
test = self.test.Pack(builder)
|
|
if self.test4 is not None:
|
|
StartTest4Vector(builder, len(self.test4))
|
|
for i in reversed(range(len(self.test4))):
|
|
self.test4[i].Pack(builder)
|
|
test4 = builder.EndVector()
|
|
if self.testarrayofstring is not None:
|
|
testarrayofstringlist = []
|
|
for i in range(len(self.testarrayofstring)):
|
|
testarrayofstringlist.append(builder.CreateString(self.testarrayofstring[i]))
|
|
StartTestarrayofstringVector(builder, len(self.testarrayofstring))
|
|
for i in reversed(range(len(self.testarrayofstring))):
|
|
builder.PrependUOffsetTRelative(testarrayofstringlist[i])
|
|
testarrayofstring = builder.EndVector()
|
|
if self.testarrayoftables is not None:
|
|
testarrayoftableslist = []
|
|
for i in range(len(self.testarrayoftables)):
|
|
testarrayoftableslist.append(self.testarrayoftables[i].Pack(builder))
|
|
StartTestarrayoftablesVector(builder, len(self.testarrayoftables))
|
|
for i in reversed(range(len(self.testarrayoftables))):
|
|
builder.PrependUOffsetTRelative(testarrayoftableslist[i])
|
|
testarrayoftables = builder.EndVector()
|
|
if self.enemy is not None:
|
|
enemy = self.enemy.Pack(builder)
|
|
if self.testnestedflatbuffer is not None:
|
|
if np is not None and type(self.testnestedflatbuffer) is np.ndarray:
|
|
testnestedflatbuffer = builder.CreateNumpyVector(self.testnestedflatbuffer)
|
|
else:
|
|
StartTestnestedflatbufferVector(builder, len(self.testnestedflatbuffer))
|
|
for i in reversed(range(len(self.testnestedflatbuffer))):
|
|
builder.PrependUint8(self.testnestedflatbuffer[i])
|
|
testnestedflatbuffer = builder.EndVector()
|
|
if self.testempty is not None:
|
|
testempty = self.testempty.Pack(builder)
|
|
if self.testarrayofbools is not None:
|
|
if np is not None and type(self.testarrayofbools) is np.ndarray:
|
|
testarrayofbools = builder.CreateNumpyVector(self.testarrayofbools)
|
|
else:
|
|
StartTestarrayofboolsVector(builder, len(self.testarrayofbools))
|
|
for i in reversed(range(len(self.testarrayofbools))):
|
|
builder.PrependBool(self.testarrayofbools[i])
|
|
testarrayofbools = builder.EndVector()
|
|
if self.testarrayofstring2 is not None:
|
|
testarrayofstring2list = []
|
|
for i in range(len(self.testarrayofstring2)):
|
|
testarrayofstring2list.append(builder.CreateString(self.testarrayofstring2[i]))
|
|
StartTestarrayofstring2Vector(builder, len(self.testarrayofstring2))
|
|
for i in reversed(range(len(self.testarrayofstring2))):
|
|
builder.PrependUOffsetTRelative(testarrayofstring2list[i])
|
|
testarrayofstring2 = builder.EndVector()
|
|
if self.testarrayofsortedstruct is not None:
|
|
StartTestarrayofsortedstructVector(builder, len(self.testarrayofsortedstruct))
|
|
for i in reversed(range(len(self.testarrayofsortedstruct))):
|
|
self.testarrayofsortedstruct[i].Pack(builder)
|
|
testarrayofsortedstruct = builder.EndVector()
|
|
if self.flex is not None:
|
|
if np is not None and type(self.flex) is np.ndarray:
|
|
flex = builder.CreateNumpyVector(self.flex)
|
|
else:
|
|
StartFlexVector(builder, len(self.flex))
|
|
for i in reversed(range(len(self.flex))):
|
|
builder.PrependUint8(self.flex[i])
|
|
flex = builder.EndVector()
|
|
if self.test5 is not None:
|
|
StartTest5Vector(builder, len(self.test5))
|
|
for i in reversed(range(len(self.test5))):
|
|
self.test5[i].Pack(builder)
|
|
test5 = builder.EndVector()
|
|
if self.vectorOfLongs is not None:
|
|
if np is not None and type(self.vectorOfLongs) is np.ndarray:
|
|
vectorOfLongs = builder.CreateNumpyVector(self.vectorOfLongs)
|
|
else:
|
|
StartVectorOfLongsVector(builder, len(self.vectorOfLongs))
|
|
for i in reversed(range(len(self.vectorOfLongs))):
|
|
builder.PrependInt64(self.vectorOfLongs[i])
|
|
vectorOfLongs = builder.EndVector()
|
|
if self.vectorOfDoubles is not None:
|
|
if np is not None and type(self.vectorOfDoubles) is np.ndarray:
|
|
vectorOfDoubles = builder.CreateNumpyVector(self.vectorOfDoubles)
|
|
else:
|
|
StartVectorOfDoublesVector(builder, len(self.vectorOfDoubles))
|
|
for i in reversed(range(len(self.vectorOfDoubles))):
|
|
builder.PrependFloat64(self.vectorOfDoubles[i])
|
|
vectorOfDoubles = builder.EndVector()
|
|
if self.parentNamespaceTest is not None:
|
|
parentNamespaceTest = self.parentNamespaceTest.Pack(builder)
|
|
if self.vectorOfReferrables is not None:
|
|
vectorOfReferrableslist = []
|
|
for i in range(len(self.vectorOfReferrables)):
|
|
vectorOfReferrableslist.append(self.vectorOfReferrables[i].Pack(builder))
|
|
StartVectorOfReferrablesVector(builder, len(self.vectorOfReferrables))
|
|
for i in reversed(range(len(self.vectorOfReferrables))):
|
|
builder.PrependUOffsetTRelative(vectorOfReferrableslist[i])
|
|
vectorOfReferrables = builder.EndVector()
|
|
if self.vectorOfWeakReferences is not None:
|
|
if np is not None and type(self.vectorOfWeakReferences) is np.ndarray:
|
|
vectorOfWeakReferences = builder.CreateNumpyVector(self.vectorOfWeakReferences)
|
|
else:
|
|
StartVectorOfWeakReferencesVector(builder, len(self.vectorOfWeakReferences))
|
|
for i in reversed(range(len(self.vectorOfWeakReferences))):
|
|
builder.PrependUint64(self.vectorOfWeakReferences[i])
|
|
vectorOfWeakReferences = builder.EndVector()
|
|
if self.vectorOfStrongReferrables is not None:
|
|
vectorOfStrongReferrableslist = []
|
|
for i in range(len(self.vectorOfStrongReferrables)):
|
|
vectorOfStrongReferrableslist.append(self.vectorOfStrongReferrables[i].Pack(builder))
|
|
StartVectorOfStrongReferrablesVector(builder, len(self.vectorOfStrongReferrables))
|
|
for i in reversed(range(len(self.vectorOfStrongReferrables))):
|
|
builder.PrependUOffsetTRelative(vectorOfStrongReferrableslist[i])
|
|
vectorOfStrongReferrables = builder.EndVector()
|
|
if self.vectorOfCoOwningReferences is not None:
|
|
if np is not None and type(self.vectorOfCoOwningReferences) is np.ndarray:
|
|
vectorOfCoOwningReferences = builder.CreateNumpyVector(self.vectorOfCoOwningReferences)
|
|
else:
|
|
StartVectorOfCoOwningReferencesVector(builder, len(self.vectorOfCoOwningReferences))
|
|
for i in reversed(range(len(self.vectorOfCoOwningReferences))):
|
|
builder.PrependUint64(self.vectorOfCoOwningReferences[i])
|
|
vectorOfCoOwningReferences = builder.EndVector()
|
|
if self.vectorOfNonOwningReferences is not None:
|
|
if np is not None and type(self.vectorOfNonOwningReferences) is np.ndarray:
|
|
vectorOfNonOwningReferences = builder.CreateNumpyVector(self.vectorOfNonOwningReferences)
|
|
else:
|
|
StartVectorOfNonOwningReferencesVector(builder, len(self.vectorOfNonOwningReferences))
|
|
for i in reversed(range(len(self.vectorOfNonOwningReferences))):
|
|
builder.PrependUint64(self.vectorOfNonOwningReferences[i])
|
|
vectorOfNonOwningReferences = builder.EndVector()
|
|
if self.anyUnique is not None:
|
|
anyUnique = self.anyUnique.Pack(builder)
|
|
if self.anyAmbiguous is not None:
|
|
anyAmbiguous = self.anyAmbiguous.Pack(builder)
|
|
if self.vectorOfEnums is not None:
|
|
if np is not None and type(self.vectorOfEnums) is np.ndarray:
|
|
vectorOfEnums = builder.CreateNumpyVector(self.vectorOfEnums)
|
|
else:
|
|
StartVectorOfEnumsVector(builder, len(self.vectorOfEnums))
|
|
for i in reversed(range(len(self.vectorOfEnums))):
|
|
builder.PrependUint8(self.vectorOfEnums[i])
|
|
vectorOfEnums = builder.EndVector()
|
|
if self.testrequirednestedflatbuffer is not None:
|
|
if np is not None and type(self.testrequirednestedflatbuffer) is np.ndarray:
|
|
testrequirednestedflatbuffer = builder.CreateNumpyVector(self.testrequirednestedflatbuffer)
|
|
else:
|
|
StartTestrequirednestedflatbufferVector(builder, len(self.testrequirednestedflatbuffer))
|
|
for i in reversed(range(len(self.testrequirednestedflatbuffer))):
|
|
builder.PrependUint8(self.testrequirednestedflatbuffer[i])
|
|
testrequirednestedflatbuffer = builder.EndVector()
|
|
if self.scalarKeySortedTables is not None:
|
|
scalarKeySortedTableslist = []
|
|
for i in range(len(self.scalarKeySortedTables)):
|
|
scalarKeySortedTableslist.append(self.scalarKeySortedTables[i].Pack(builder))
|
|
StartScalarKeySortedTablesVector(builder, len(self.scalarKeySortedTables))
|
|
for i in reversed(range(len(self.scalarKeySortedTables))):
|
|
builder.PrependUOffsetTRelative(scalarKeySortedTableslist[i])
|
|
scalarKeySortedTables = builder.EndVector()
|
|
Start(builder)
|
|
if self.pos is not None:
|
|
pos = self.pos.Pack(builder)
|
|
AddPos(builder, pos)
|
|
AddMana(builder, self.mana)
|
|
AddHp(builder, self.hp)
|
|
if self.name is not None:
|
|
AddName(builder, name)
|
|
if self.inventory is not None:
|
|
AddInventory(builder, inventory)
|
|
AddColor(builder, self.color)
|
|
AddTestType(builder, self.testType)
|
|
if self.test is not None:
|
|
AddTest(builder, test)
|
|
if self.test4 is not None:
|
|
AddTest4(builder, test4)
|
|
if self.testarrayofstring is not None:
|
|
AddTestarrayofstring(builder, testarrayofstring)
|
|
if self.testarrayoftables is not None:
|
|
AddTestarrayoftables(builder, testarrayoftables)
|
|
if self.enemy is not None:
|
|
AddEnemy(builder, enemy)
|
|
if self.testnestedflatbuffer is not None:
|
|
AddTestnestedflatbuffer(builder, testnestedflatbuffer)
|
|
if self.testempty is not None:
|
|
AddTestempty(builder, testempty)
|
|
AddTestbool(builder, self.testbool)
|
|
AddTesthashs32Fnv1(builder, self.testhashs32Fnv1)
|
|
AddTesthashu32Fnv1(builder, self.testhashu32Fnv1)
|
|
AddTesthashs64Fnv1(builder, self.testhashs64Fnv1)
|
|
AddTesthashu64Fnv1(builder, self.testhashu64Fnv1)
|
|
AddTesthashs32Fnv1a(builder, self.testhashs32Fnv1a)
|
|
AddTesthashu32Fnv1a(builder, self.testhashu32Fnv1a)
|
|
AddTesthashs64Fnv1a(builder, self.testhashs64Fnv1a)
|
|
AddTesthashu64Fnv1a(builder, self.testhashu64Fnv1a)
|
|
if self.testarrayofbools is not None:
|
|
AddTestarrayofbools(builder, testarrayofbools)
|
|
AddTestf(builder, self.testf)
|
|
AddTestf2(builder, self.testf2)
|
|
AddTestf3(builder, self.testf3)
|
|
if self.testarrayofstring2 is not None:
|
|
AddTestarrayofstring2(builder, testarrayofstring2)
|
|
if self.testarrayofsortedstruct is not None:
|
|
AddTestarrayofsortedstruct(builder, testarrayofsortedstruct)
|
|
if self.flex is not None:
|
|
AddFlex(builder, flex)
|
|
if self.test5 is not None:
|
|
AddTest5(builder, test5)
|
|
if self.vectorOfLongs is not None:
|
|
AddVectorOfLongs(builder, vectorOfLongs)
|
|
if self.vectorOfDoubles is not None:
|
|
AddVectorOfDoubles(builder, vectorOfDoubles)
|
|
if self.parentNamespaceTest is not None:
|
|
AddParentNamespaceTest(builder, parentNamespaceTest)
|
|
if self.vectorOfReferrables is not None:
|
|
AddVectorOfReferrables(builder, vectorOfReferrables)
|
|
AddSingleWeakReference(builder, self.singleWeakReference)
|
|
if self.vectorOfWeakReferences is not None:
|
|
AddVectorOfWeakReferences(builder, vectorOfWeakReferences)
|
|
if self.vectorOfStrongReferrables is not None:
|
|
AddVectorOfStrongReferrables(builder, vectorOfStrongReferrables)
|
|
AddCoOwningReference(builder, self.coOwningReference)
|
|
if self.vectorOfCoOwningReferences is not None:
|
|
AddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences)
|
|
AddNonOwningReference(builder, self.nonOwningReference)
|
|
if self.vectorOfNonOwningReferences is not None:
|
|
AddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences)
|
|
AddAnyUniqueType(builder, self.anyUniqueType)
|
|
if self.anyUnique is not None:
|
|
AddAnyUnique(builder, anyUnique)
|
|
AddAnyAmbiguousType(builder, self.anyAmbiguousType)
|
|
if self.anyAmbiguous is not None:
|
|
AddAnyAmbiguous(builder, anyAmbiguous)
|
|
if self.vectorOfEnums is not None:
|
|
AddVectorOfEnums(builder, vectorOfEnums)
|
|
AddSignedEnum(builder, self.signedEnum)
|
|
if self.testrequirednestedflatbuffer is not None:
|
|
AddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer)
|
|
if self.scalarKeySortedTables is not None:
|
|
AddScalarKeySortedTables(builder, scalarKeySortedTables)
|
|
monster = End(builder)
|
|
return monster
|