• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1# automatically generated by the FlatBuffers compiler, do not modify
2
3# namespace: Example
4
5import flatbuffers
6from flatbuffers.compat import import_numpy
7np = import_numpy()
8
9# an example documentation comment: "monster object"
10class Monster(object):
11    __slots__ = ['_tab']
12
13    @classmethod
14    def GetRootAsMonster(cls, buf, offset):
15        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
16        x = Monster()
17        x.Init(buf, n + offset)
18        return x
19
20    @classmethod
21    def MonsterBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
22        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x4F\x4E\x53", size_prefixed=size_prefixed)
23
24    # Monster
25    def Init(self, buf, pos):
26        self._tab = flatbuffers.table.Table(buf, pos)
27
28    # Monster
29    def Pos(self):
30        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
31        if o != 0:
32            x = o + self._tab.Pos
33            from MyGame.Example.Vec3 import Vec3
34            obj = Vec3()
35            obj.Init(self._tab.Bytes, x)
36            return obj
37        return None
38
39    # Monster
40    def Mana(self):
41        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
42        if o != 0:
43            return self._tab.Get(flatbuffers.number_types.Int16Flags, o + self._tab.Pos)
44        return 150
45
46    # Monster
47    def Hp(self):
48        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
49        if o != 0:
50            return self._tab.Get(flatbuffers.number_types.Int16Flags, o + self._tab.Pos)
51        return 100
52
53    # Monster
54    def Name(self):
55        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
56        if o != 0:
57            return self._tab.String(o + self._tab.Pos)
58        return None
59
60    # Monster
61    def Inventory(self, j):
62        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
63        if o != 0:
64            a = self._tab.Vector(o)
65            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
66        return 0
67
68    # Monster
69    def InventoryAsNumpy(self):
70        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
71        if o != 0:
72            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
73        return 0
74
75    # Monster
76    def InventoryLength(self):
77        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
78        if o != 0:
79            return self._tab.VectorLen(o)
80        return 0
81
82    # Monster
83    def InventoryIsNone(self):
84        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
85        return o == 0
86
87    # Monster
88    def Color(self):
89        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
90        if o != 0:
91            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
92        return 8
93
94    # Monster
95    def TestType(self):
96        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
97        if o != 0:
98            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
99        return 0
100
101    # Monster
102    def Test(self):
103        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
104        if o != 0:
105            from flatbuffers.table import Table
106            obj = Table(bytearray(), 0)
107            self._tab.Union(obj, o)
108            return obj
109        return None
110
111    # Monster
112    def Test4(self, j):
113        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
114        if o != 0:
115            x = self._tab.Vector(o)
116            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
117            from MyGame.Example.Test import Test
118            obj = Test()
119            obj.Init(self._tab.Bytes, x)
120            return obj
121        return None
122
123    # Monster
124    def Test4Length(self):
125        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
126        if o != 0:
127            return self._tab.VectorLen(o)
128        return 0
129
130    # Monster
131    def Test4IsNone(self):
132        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
133        return o == 0
134
135    # Monster
136    def Testarrayofstring(self, j):
137        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
138        if o != 0:
139            a = self._tab.Vector(o)
140            return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
141        return ""
142
143    # Monster
144    def TestarrayofstringLength(self):
145        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
146        if o != 0:
147            return self._tab.VectorLen(o)
148        return 0
149
150    # Monster
151    def TestarrayofstringIsNone(self):
152        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
153        return o == 0
154
155    # an example documentation comment: this will end up in the generated code
156    # multiline too
157    # Monster
158    def Testarrayoftables(self, j):
159        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
160        if o != 0:
161            x = self._tab.Vector(o)
162            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
163            x = self._tab.Indirect(x)
164            from MyGame.Example.Monster import Monster
165            obj = Monster()
166            obj.Init(self._tab.Bytes, x)
167            return obj
168        return None
169
170    # Monster
171    def TestarrayoftablesLength(self):
172        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
173        if o != 0:
174            return self._tab.VectorLen(o)
175        return 0
176
177    # Monster
178    def TestarrayoftablesIsNone(self):
179        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
180        return o == 0
181
182    # Monster
183    def Enemy(self):
184        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
185        if o != 0:
186            x = self._tab.Indirect(o + self._tab.Pos)
187            from MyGame.Example.Monster import Monster
188            obj = Monster()
189            obj.Init(self._tab.Bytes, x)
190            return obj
191        return None
192
193    # Monster
194    def Testnestedflatbuffer(self, j):
195        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
196        if o != 0:
197            a = self._tab.Vector(o)
198            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
199        return 0
200
201    # Monster
202    def TestnestedflatbufferAsNumpy(self):
203        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
204        if o != 0:
205            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
206        return 0
207
208    # Monster
209    def TestnestedflatbufferLength(self):
210        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
211        if o != 0:
212            return self._tab.VectorLen(o)
213        return 0
214
215    # Monster
216    def TestnestedflatbufferIsNone(self):
217        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
218        return o == 0
219
220    # Monster
221    def Testempty(self):
222        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
223        if o != 0:
224            x = self._tab.Indirect(o + self._tab.Pos)
225            from MyGame.Example.Stat import Stat
226            obj = Stat()
227            obj.Init(self._tab.Bytes, x)
228            return obj
229        return None
230
231    # Monster
232    def Testbool(self):
233        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
234        if o != 0:
235            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
236        return False
237
238    # Monster
239    def Testhashs32Fnv1(self):
240        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
241        if o != 0:
242            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
243        return 0
244
245    # Monster
246    def Testhashu32Fnv1(self):
247        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(38))
248        if o != 0:
249            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
250        return 0
251
252    # Monster
253    def Testhashs64Fnv1(self):
254        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(40))
255        if o != 0:
256            return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
257        return 0
258
259    # Monster
260    def Testhashu64Fnv1(self):
261        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(42))
262        if o != 0:
263            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
264        return 0
265
266    # Monster
267    def Testhashs32Fnv1a(self):
268        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(44))
269        if o != 0:
270            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
271        return 0
272
273    # Monster
274    def Testhashu32Fnv1a(self):
275        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(46))
276        if o != 0:
277            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
278        return 0
279
280    # Monster
281    def Testhashs64Fnv1a(self):
282        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(48))
283        if o != 0:
284            return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
285        return 0
286
287    # Monster
288    def Testhashu64Fnv1a(self):
289        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(50))
290        if o != 0:
291            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
292        return 0
293
294    # Monster
295    def Testarrayofbools(self, j):
296        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
297        if o != 0:
298            a = self._tab.Vector(o)
299            return self._tab.Get(flatbuffers.number_types.BoolFlags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
300        return 0
301
302    # Monster
303    def TestarrayofboolsAsNumpy(self):
304        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
305        if o != 0:
306            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.BoolFlags, o)
307        return 0
308
309    # Monster
310    def TestarrayofboolsLength(self):
311        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
312        if o != 0:
313            return self._tab.VectorLen(o)
314        return 0
315
316    # Monster
317    def TestarrayofboolsIsNone(self):
318        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
319        return o == 0
320
321    # Monster
322    def Testf(self):
323        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(54))
324        if o != 0:
325            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
326        return 3.14159
327
328    # Monster
329    def Testf2(self):
330        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(56))
331        if o != 0:
332            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
333        return 3.0
334
335    # Monster
336    def Testf3(self):
337        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(58))
338        if o != 0:
339            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
340        return 0.0
341
342    # Monster
343    def Testarrayofstring2(self, j):
344        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(60))
345        if o != 0:
346            a = self._tab.Vector(o)
347            return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
348        return ""
349
350    # Monster
351    def Testarrayofstring2Length(self):
352        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(60))
353        if o != 0:
354            return self._tab.VectorLen(o)
355        return 0
356
357    # Monster
358    def Testarrayofstring2IsNone(self):
359        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(60))
360        return o == 0
361
362    # Monster
363    def Testarrayofsortedstruct(self, j):
364        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(62))
365        if o != 0:
366            x = self._tab.Vector(o)
367            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 8
368            from MyGame.Example.Ability import Ability
369            obj = Ability()
370            obj.Init(self._tab.Bytes, x)
371            return obj
372        return None
373
374    # Monster
375    def TestarrayofsortedstructLength(self):
376        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(62))
377        if o != 0:
378            return self._tab.VectorLen(o)
379        return 0
380
381    # Monster
382    def TestarrayofsortedstructIsNone(self):
383        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(62))
384        return o == 0
385
386    # Monster
387    def Flex(self, j):
388        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
389        if o != 0:
390            a = self._tab.Vector(o)
391            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
392        return 0
393
394    # Monster
395    def FlexAsNumpy(self):
396        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
397        if o != 0:
398            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
399        return 0
400
401    # Monster
402    def FlexLength(self):
403        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
404        if o != 0:
405            return self._tab.VectorLen(o)
406        return 0
407
408    # Monster
409    def FlexIsNone(self):
410        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
411        return o == 0
412
413    # Monster
414    def Test5(self, j):
415        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(66))
416        if o != 0:
417            x = self._tab.Vector(o)
418            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
419            from MyGame.Example.Test import Test
420            obj = Test()
421            obj.Init(self._tab.Bytes, x)
422            return obj
423        return None
424
425    # Monster
426    def Test5Length(self):
427        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(66))
428        if o != 0:
429            return self._tab.VectorLen(o)
430        return 0
431
432    # Monster
433    def Test5IsNone(self):
434        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(66))
435        return o == 0
436
437    # Monster
438    def VectorOfLongs(self, j):
439        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
440        if o != 0:
441            a = self._tab.Vector(o)
442            return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
443        return 0
444
445    # Monster
446    def VectorOfLongsAsNumpy(self):
447        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
448        if o != 0:
449            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o)
450        return 0
451
452    # Monster
453    def VectorOfLongsLength(self):
454        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
455        if o != 0:
456            return self._tab.VectorLen(o)
457        return 0
458
459    # Monster
460    def VectorOfLongsIsNone(self):
461        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
462        return o == 0
463
464    # Monster
465    def VectorOfDoubles(self, j):
466        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
467        if o != 0:
468            a = self._tab.Vector(o)
469            return self._tab.Get(flatbuffers.number_types.Float64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
470        return 0
471
472    # Monster
473    def VectorOfDoublesAsNumpy(self):
474        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
475        if o != 0:
476            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float64Flags, o)
477        return 0
478
479    # Monster
480    def VectorOfDoublesLength(self):
481        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
482        if o != 0:
483            return self._tab.VectorLen(o)
484        return 0
485
486    # Monster
487    def VectorOfDoublesIsNone(self):
488        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
489        return o == 0
490
491    # Monster
492    def ParentNamespaceTest(self):
493        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(72))
494        if o != 0:
495            x = self._tab.Indirect(o + self._tab.Pos)
496            from MyGame.InParentNamespace import InParentNamespace
497            obj = InParentNamespace()
498            obj.Init(self._tab.Bytes, x)
499            return obj
500        return None
501
502    # Monster
503    def VectorOfReferrables(self, j):
504        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(74))
505        if o != 0:
506            x = self._tab.Vector(o)
507            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
508            x = self._tab.Indirect(x)
509            from MyGame.Example.Referrable import Referrable
510            obj = Referrable()
511            obj.Init(self._tab.Bytes, x)
512            return obj
513        return None
514
515    # Monster
516    def VectorOfReferrablesLength(self):
517        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(74))
518        if o != 0:
519            return self._tab.VectorLen(o)
520        return 0
521
522    # Monster
523    def VectorOfReferrablesIsNone(self):
524        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(74))
525        return o == 0
526
527    # Monster
528    def SingleWeakReference(self):
529        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(76))
530        if o != 0:
531            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
532        return 0
533
534    # Monster
535    def VectorOfWeakReferences(self, j):
536        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(78))
537        if o != 0:
538            a = self._tab.Vector(o)
539            return self._tab.Get(flatbuffers.number_types.Uint64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
540        return 0
541
542    # Monster
543    def VectorOfWeakReferencesAsNumpy(self):
544        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(78))
545        if o != 0:
546            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint64Flags, o)
547        return 0
548
549    # Monster
550    def VectorOfWeakReferencesLength(self):
551        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(78))
552        if o != 0:
553            return self._tab.VectorLen(o)
554        return 0
555
556    # Monster
557    def VectorOfWeakReferencesIsNone(self):
558        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(78))
559        return o == 0
560
561    # Monster
562    def VectorOfStrongReferrables(self, j):
563        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(80))
564        if o != 0:
565            x = self._tab.Vector(o)
566            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
567            x = self._tab.Indirect(x)
568            from MyGame.Example.Referrable import Referrable
569            obj = Referrable()
570            obj.Init(self._tab.Bytes, x)
571            return obj
572        return None
573
574    # Monster
575    def VectorOfStrongReferrablesLength(self):
576        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(80))
577        if o != 0:
578            return self._tab.VectorLen(o)
579        return 0
580
581    # Monster
582    def VectorOfStrongReferrablesIsNone(self):
583        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(80))
584        return o == 0
585
586    # Monster
587    def CoOwningReference(self):
588        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(82))
589        if o != 0:
590            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
591        return 0
592
593    # Monster
594    def VectorOfCoOwningReferences(self, j):
595        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(84))
596        if o != 0:
597            a = self._tab.Vector(o)
598            return self._tab.Get(flatbuffers.number_types.Uint64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
599        return 0
600
601    # Monster
602    def VectorOfCoOwningReferencesAsNumpy(self):
603        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(84))
604        if o != 0:
605            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint64Flags, o)
606        return 0
607
608    # Monster
609    def VectorOfCoOwningReferencesLength(self):
610        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(84))
611        if o != 0:
612            return self._tab.VectorLen(o)
613        return 0
614
615    # Monster
616    def VectorOfCoOwningReferencesIsNone(self):
617        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(84))
618        return o == 0
619
620    # Monster
621    def NonOwningReference(self):
622        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(86))
623        if o != 0:
624            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
625        return 0
626
627    # Monster
628    def VectorOfNonOwningReferences(self, j):
629        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
630        if o != 0:
631            a = self._tab.Vector(o)
632            return self._tab.Get(flatbuffers.number_types.Uint64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
633        return 0
634
635    # Monster
636    def VectorOfNonOwningReferencesAsNumpy(self):
637        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
638        if o != 0:
639            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint64Flags, o)
640        return 0
641
642    # Monster
643    def VectorOfNonOwningReferencesLength(self):
644        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
645        if o != 0:
646            return self._tab.VectorLen(o)
647        return 0
648
649    # Monster
650    def VectorOfNonOwningReferencesIsNone(self):
651        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
652        return o == 0
653
654    # Monster
655    def AnyUniqueType(self):
656        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(90))
657        if o != 0:
658            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
659        return 0
660
661    # Monster
662    def AnyUnique(self):
663        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(92))
664        if o != 0:
665            from flatbuffers.table import Table
666            obj = Table(bytearray(), 0)
667            self._tab.Union(obj, o)
668            return obj
669        return None
670
671    # Monster
672    def AnyAmbiguousType(self):
673        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(94))
674        if o != 0:
675            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
676        return 0
677
678    # Monster
679    def AnyAmbiguous(self):
680        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(96))
681        if o != 0:
682            from flatbuffers.table import Table
683            obj = Table(bytearray(), 0)
684            self._tab.Union(obj, o)
685            return obj
686        return None
687
688    # Monster
689    def VectorOfEnums(self, j):
690        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
691        if o != 0:
692            a = self._tab.Vector(o)
693            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
694        return 0
695
696    # Monster
697    def VectorOfEnumsAsNumpy(self):
698        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
699        if o != 0:
700            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
701        return 0
702
703    # Monster
704    def VectorOfEnumsLength(self):
705        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
706        if o != 0:
707            return self._tab.VectorLen(o)
708        return 0
709
710    # Monster
711    def VectorOfEnumsIsNone(self):
712        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
713        return o == 0
714
715    # Monster
716    def SignedEnum(self):
717        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(100))
718        if o != 0:
719            return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
720        return -1
721
722def MonsterStart(builder): builder.StartObject(49)
723def MonsterAddPos(builder, pos): builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pos), 0)
724def MonsterAddMana(builder, mana): builder.PrependInt16Slot(1, mana, 150)
725def MonsterAddHp(builder, hp): builder.PrependInt16Slot(2, hp, 100)
726def MonsterAddName(builder, name): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
727def MonsterAddInventory(builder, inventory): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(inventory), 0)
728def MonsterStartInventoryVector(builder, numElems): return builder.StartVector(1, numElems, 1)
729def MonsterAddColor(builder, color): builder.PrependUint8Slot(6, color, 8)
730def MonsterAddTestType(builder, testType): builder.PrependUint8Slot(7, testType, 0)
731def MonsterAddTest(builder, test): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(test), 0)
732def MonsterAddTest4(builder, test4): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(test4), 0)
733def MonsterStartTest4Vector(builder, numElems): return builder.StartVector(4, numElems, 2)
734def MonsterAddTestarrayofstring(builder, testarrayofstring): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring), 0)
735def MonsterStartTestarrayofstringVector(builder, numElems): return builder.StartVector(4, numElems, 4)
736def MonsterAddTestarrayoftables(builder, testarrayoftables): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayoftables), 0)
737def MonsterStartTestarrayoftablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
738def MonsterAddEnemy(builder, enemy): builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(enemy), 0)
739def MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer): builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(testnestedflatbuffer), 0)
740def MonsterStartTestnestedflatbufferVector(builder, numElems): return builder.StartVector(1, numElems, 1)
741def MonsterAddTestempty(builder, testempty): builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(testempty), 0)
742def MonsterAddTestbool(builder, testbool): builder.PrependBoolSlot(15, testbool, 0)
743def MonsterAddTesthashs32Fnv1(builder, testhashs32Fnv1): builder.PrependInt32Slot(16, testhashs32Fnv1, 0)
744def MonsterAddTesthashu32Fnv1(builder, testhashu32Fnv1): builder.PrependUint32Slot(17, testhashu32Fnv1, 0)
745def MonsterAddTesthashs64Fnv1(builder, testhashs64Fnv1): builder.PrependInt64Slot(18, testhashs64Fnv1, 0)
746def MonsterAddTesthashu64Fnv1(builder, testhashu64Fnv1): builder.PrependUint64Slot(19, testhashu64Fnv1, 0)
747def MonsterAddTesthashs32Fnv1a(builder, testhashs32Fnv1a): builder.PrependInt32Slot(20, testhashs32Fnv1a, 0)
748def MonsterAddTesthashu32Fnv1a(builder, testhashu32Fnv1a): builder.PrependUint32Slot(21, testhashu32Fnv1a, 0)
749def MonsterAddTesthashs64Fnv1a(builder, testhashs64Fnv1a): builder.PrependInt64Slot(22, testhashs64Fnv1a, 0)
750def MonsterAddTesthashu64Fnv1a(builder, testhashu64Fnv1a): builder.PrependUint64Slot(23, testhashu64Fnv1a, 0)
751def MonsterAddTestarrayofbools(builder, testarrayofbools): builder.PrependUOffsetTRelativeSlot(24, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofbools), 0)
752def MonsterStartTestarrayofboolsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
753def MonsterAddTestf(builder, testf): builder.PrependFloat32Slot(25, testf, 3.14159)
754def MonsterAddTestf2(builder, testf2): builder.PrependFloat32Slot(26, testf2, 3.0)
755def MonsterAddTestf3(builder, testf3): builder.PrependFloat32Slot(27, testf3, 0.0)
756def MonsterAddTestarrayofstring2(builder, testarrayofstring2): builder.PrependUOffsetTRelativeSlot(28, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring2), 0)
757def MonsterStartTestarrayofstring2Vector(builder, numElems): return builder.StartVector(4, numElems, 4)
758def MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct): builder.PrependUOffsetTRelativeSlot(29, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofsortedstruct), 0)
759def MonsterStartTestarrayofsortedstructVector(builder, numElems): return builder.StartVector(8, numElems, 4)
760def MonsterAddFlex(builder, flex): builder.PrependUOffsetTRelativeSlot(30, flatbuffers.number_types.UOffsetTFlags.py_type(flex), 0)
761def MonsterStartFlexVector(builder, numElems): return builder.StartVector(1, numElems, 1)
762def MonsterAddTest5(builder, test5): builder.PrependUOffsetTRelativeSlot(31, flatbuffers.number_types.UOffsetTFlags.py_type(test5), 0)
763def MonsterStartTest5Vector(builder, numElems): return builder.StartVector(4, numElems, 2)
764def MonsterAddVectorOfLongs(builder, vectorOfLongs): builder.PrependUOffsetTRelativeSlot(32, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfLongs), 0)
765def MonsterStartVectorOfLongsVector(builder, numElems): return builder.StartVector(8, numElems, 8)
766def MonsterAddVectorOfDoubles(builder, vectorOfDoubles): builder.PrependUOffsetTRelativeSlot(33, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfDoubles), 0)
767def MonsterStartVectorOfDoublesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
768def MonsterAddParentNamespaceTest(builder, parentNamespaceTest): builder.PrependUOffsetTRelativeSlot(34, flatbuffers.number_types.UOffsetTFlags.py_type(parentNamespaceTest), 0)
769def MonsterAddVectorOfReferrables(builder, vectorOfReferrables): builder.PrependUOffsetTRelativeSlot(35, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfReferrables), 0)
770def MonsterStartVectorOfReferrablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
771def MonsterAddSingleWeakReference(builder, singleWeakReference): builder.PrependUint64Slot(36, singleWeakReference, 0)
772def MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences): builder.PrependUOffsetTRelativeSlot(37, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfWeakReferences), 0)
773def MonsterStartVectorOfWeakReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
774def MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables): builder.PrependUOffsetTRelativeSlot(38, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfStrongReferrables), 0)
775def MonsterStartVectorOfStrongReferrablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
776def MonsterAddCoOwningReference(builder, coOwningReference): builder.PrependUint64Slot(39, coOwningReference, 0)
777def MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences): builder.PrependUOffsetTRelativeSlot(40, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfCoOwningReferences), 0)
778def MonsterStartVectorOfCoOwningReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
779def MonsterAddNonOwningReference(builder, nonOwningReference): builder.PrependUint64Slot(41, nonOwningReference, 0)
780def MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences): builder.PrependUOffsetTRelativeSlot(42, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfNonOwningReferences), 0)
781def MonsterStartVectorOfNonOwningReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
782def MonsterAddAnyUniqueType(builder, anyUniqueType): builder.PrependUint8Slot(43, anyUniqueType, 0)
783def MonsterAddAnyUnique(builder, anyUnique): builder.PrependUOffsetTRelativeSlot(44, flatbuffers.number_types.UOffsetTFlags.py_type(anyUnique), 0)
784def MonsterAddAnyAmbiguousType(builder, anyAmbiguousType): builder.PrependUint8Slot(45, anyAmbiguousType, 0)
785def MonsterAddAnyAmbiguous(builder, anyAmbiguous): builder.PrependUOffsetTRelativeSlot(46, flatbuffers.number_types.UOffsetTFlags.py_type(anyAmbiguous), 0)
786def MonsterAddVectorOfEnums(builder, vectorOfEnums): builder.PrependUOffsetTRelativeSlot(47, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfEnums), 0)
787def MonsterStartVectorOfEnumsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
788def MonsterAddSignedEnum(builder, signedEnum): builder.PrependInt8Slot(48, signedEnum, -1)
789def MonsterEnd(builder): return builder.EndObject()
790
791import MyGame.Example.Ability
792import MyGame.Example.Any
793import MyGame.Example.AnyAmbiguousAliases
794import MyGame.Example.AnyUniqueAliases
795import MyGame.Example.Referrable
796import MyGame.Example.Stat
797import MyGame.Example.Test
798import MyGame.Example.TestSimpleTableWithEnum
799import MyGame.Example.Vec3
800import MyGame.Example2.Monster
801import MyGame.InParentNamespace
802try:
803    from typing import List, Optional, Union
804except:
805    pass
806
807class MonsterT(object):
808
809    # MonsterT
810    def __init__(self):
811        self.pos = None  # type: Optional[MyGame.Example.Vec3.Vec3T]
812        self.mana = 150  # type: int
813        self.hp = 100  # type: int
814        self.name = None  # type: str
815        self.inventory = None  # type: List[int]
816        self.color = 8  # type: int
817        self.testType = 0  # type: int
818        self.test = None  # type: Union[None, MyGame.Example.Monster.MonsterT, MyGame.Example.TestSimpleTableWithEnum.TestSimpleTableWithEnumT, MyGame.Example2.Monster.MonsterT]
819        self.test4 = None  # type: List[MyGame.Example.Test.TestT]
820        self.testarrayofstring = None  # type: List[str]
821        self.testarrayoftables = None  # type: List[MyGame.Example.Monster.MonsterT]
822        self.enemy = None  # type: Optional[MyGame.Example.Monster.MonsterT]
823        self.testnestedflatbuffer = None  # type: List[int]
824        self.testempty = None  # type: Optional[MyGame.Example.Stat.StatT]
825        self.testbool = False  # type: bool
826        self.testhashs32Fnv1 = 0  # type: int
827        self.testhashu32Fnv1 = 0  # type: int
828        self.testhashs64Fnv1 = 0  # type: int
829        self.testhashu64Fnv1 = 0  # type: int
830        self.testhashs32Fnv1a = 0  # type: int
831        self.testhashu32Fnv1a = 0  # type: int
832        self.testhashs64Fnv1a = 0  # type: int
833        self.testhashu64Fnv1a = 0  # type: int
834        self.testarrayofbools = None  # type: List[bool]
835        self.testf = 3.14159  # type: float
836        self.testf2 = 3.0  # type: float
837        self.testf3 = 0.0  # type: float
838        self.testarrayofstring2 = None  # type: List[str]
839        self.testarrayofsortedstruct = None  # type: List[MyGame.Example.Ability.AbilityT]
840        self.flex = None  # type: List[int]
841        self.test5 = None  # type: List[MyGame.Example.Test.TestT]
842        self.vectorOfLongs = None  # type: List[int]
843        self.vectorOfDoubles = None  # type: List[float]
844        self.parentNamespaceTest = None  # type: Optional[MyGame.InParentNamespace.InParentNamespaceT]
845        self.vectorOfReferrables = None  # type: List[MyGame.Example.Referrable.ReferrableT]
846        self.singleWeakReference = 0  # type: int
847        self.vectorOfWeakReferences = None  # type: List[int]
848        self.vectorOfStrongReferrables = None  # type: List[MyGame.Example.Referrable.ReferrableT]
849        self.coOwningReference = 0  # type: int
850        self.vectorOfCoOwningReferences = None  # type: List[int]
851        self.nonOwningReference = 0  # type: int
852        self.vectorOfNonOwningReferences = None  # type: List[int]
853        self.anyUniqueType = 0  # type: int
854        self.anyUnique = None  # type: Union[None, MyGame.Example.Monster.MonsterT, MyGame.Example.TestSimpleTableWithEnum.TestSimpleTableWithEnumT, MyGame.Example2.Monster.MonsterT]
855        self.anyAmbiguousType = 0  # type: int
856        self.anyAmbiguous = None  # type: Union[None, MyGame.Example.Monster.MonsterT, MyGame.Example.Monster.MonsterT, MyGame.Example.Monster.MonsterT]
857        self.vectorOfEnums = None  # type: List[int]
858        self.signedEnum = -1  # type: int
859
860    @classmethod
861    def InitFromBuf(cls, buf, pos):
862        monster = Monster()
863        monster.Init(buf, pos)
864        return cls.InitFromObj(monster)
865
866    @classmethod
867    def InitFromObj(cls, monster):
868        x = MonsterT()
869        x._UnPack(monster)
870        return x
871
872    # MonsterT
873    def _UnPack(self, monster):
874        if monster is None:
875            return
876        if monster.Pos() is not None:
877            self.pos = MyGame.Example.Vec3.Vec3T.InitFromObj(monster.Pos())
878        self.mana = monster.Mana()
879        self.hp = monster.Hp()
880        self.name = monster.Name()
881        if not monster.InventoryIsNone():
882            if np is None:
883                self.inventory = []
884                for i in range(monster.InventoryLength()):
885                    self.inventory.append(monster.Inventory(i))
886            else:
887                self.inventory = monster.InventoryAsNumpy()
888        self.color = monster.Color()
889        self.testType = monster.TestType()
890        self.test = MyGame.Example.Any.AnyCreator(self.testType, monster.Test())
891        if not monster.Test4IsNone():
892            self.test4 = []
893            for i in range(monster.Test4Length()):
894                if monster.Test4(i) is None:
895                    self.test4.append(None)
896                else:
897                    test_ = MyGame.Example.Test.TestT.InitFromObj(monster.Test4(i))
898                    self.test4.append(test_)
899        if not monster.TestarrayofstringIsNone():
900            self.testarrayofstring = []
901            for i in range(monster.TestarrayofstringLength()):
902                self.testarrayofstring.append(monster.Testarrayofstring(i))
903        if not monster.TestarrayoftablesIsNone():
904            self.testarrayoftables = []
905            for i in range(monster.TestarrayoftablesLength()):
906                if monster.Testarrayoftables(i) is None:
907                    self.testarrayoftables.append(None)
908                else:
909                    monster_ = MyGame.Example.Monster.MonsterT.InitFromObj(monster.Testarrayoftables(i))
910                    self.testarrayoftables.append(monster_)
911        if monster.Enemy() is not None:
912            self.enemy = MyGame.Example.Monster.MonsterT.InitFromObj(monster.Enemy())
913        if not monster.TestnestedflatbufferIsNone():
914            if np is None:
915                self.testnestedflatbuffer = []
916                for i in range(monster.TestnestedflatbufferLength()):
917                    self.testnestedflatbuffer.append(monster.Testnestedflatbuffer(i))
918            else:
919                self.testnestedflatbuffer = monster.TestnestedflatbufferAsNumpy()
920        if monster.Testempty() is not None:
921            self.testempty = MyGame.Example.Stat.StatT.InitFromObj(monster.Testempty())
922        self.testbool = monster.Testbool()
923        self.testhashs32Fnv1 = monster.Testhashs32Fnv1()
924        self.testhashu32Fnv1 = monster.Testhashu32Fnv1()
925        self.testhashs64Fnv1 = monster.Testhashs64Fnv1()
926        self.testhashu64Fnv1 = monster.Testhashu64Fnv1()
927        self.testhashs32Fnv1a = monster.Testhashs32Fnv1a()
928        self.testhashu32Fnv1a = monster.Testhashu32Fnv1a()
929        self.testhashs64Fnv1a = monster.Testhashs64Fnv1a()
930        self.testhashu64Fnv1a = monster.Testhashu64Fnv1a()
931        if not monster.TestarrayofboolsIsNone():
932            if np is None:
933                self.testarrayofbools = []
934                for i in range(monster.TestarrayofboolsLength()):
935                    self.testarrayofbools.append(monster.Testarrayofbools(i))
936            else:
937                self.testarrayofbools = monster.TestarrayofboolsAsNumpy()
938        self.testf = monster.Testf()
939        self.testf2 = monster.Testf2()
940        self.testf3 = monster.Testf3()
941        if not monster.Testarrayofstring2IsNone():
942            self.testarrayofstring2 = []
943            for i in range(monster.Testarrayofstring2Length()):
944                self.testarrayofstring2.append(monster.Testarrayofstring2(i))
945        if not monster.TestarrayofsortedstructIsNone():
946            self.testarrayofsortedstruct = []
947            for i in range(monster.TestarrayofsortedstructLength()):
948                if monster.Testarrayofsortedstruct(i) is None:
949                    self.testarrayofsortedstruct.append(None)
950                else:
951                    ability_ = MyGame.Example.Ability.AbilityT.InitFromObj(monster.Testarrayofsortedstruct(i))
952                    self.testarrayofsortedstruct.append(ability_)
953        if not monster.FlexIsNone():
954            if np is None:
955                self.flex = []
956                for i in range(monster.FlexLength()):
957                    self.flex.append(monster.Flex(i))
958            else:
959                self.flex = monster.FlexAsNumpy()
960        if not monster.Test5IsNone():
961            self.test5 = []
962            for i in range(monster.Test5Length()):
963                if monster.Test5(i) is None:
964                    self.test5.append(None)
965                else:
966                    test_ = MyGame.Example.Test.TestT.InitFromObj(monster.Test5(i))
967                    self.test5.append(test_)
968        if not monster.VectorOfLongsIsNone():
969            if np is None:
970                self.vectorOfLongs = []
971                for i in range(monster.VectorOfLongsLength()):
972                    self.vectorOfLongs.append(monster.VectorOfLongs(i))
973            else:
974                self.vectorOfLongs = monster.VectorOfLongsAsNumpy()
975        if not monster.VectorOfDoublesIsNone():
976            if np is None:
977                self.vectorOfDoubles = []
978                for i in range(monster.VectorOfDoublesLength()):
979                    self.vectorOfDoubles.append(monster.VectorOfDoubles(i))
980            else:
981                self.vectorOfDoubles = monster.VectorOfDoublesAsNumpy()
982        if monster.ParentNamespaceTest() is not None:
983            self.parentNamespaceTest = MyGame.InParentNamespace.InParentNamespaceT.InitFromObj(monster.ParentNamespaceTest())
984        if not monster.VectorOfReferrablesIsNone():
985            self.vectorOfReferrables = []
986            for i in range(monster.VectorOfReferrablesLength()):
987                if monster.VectorOfReferrables(i) is None:
988                    self.vectorOfReferrables.append(None)
989                else:
990                    referrable_ = MyGame.Example.Referrable.ReferrableT.InitFromObj(monster.VectorOfReferrables(i))
991                    self.vectorOfReferrables.append(referrable_)
992        self.singleWeakReference = monster.SingleWeakReference()
993        if not monster.VectorOfWeakReferencesIsNone():
994            if np is None:
995                self.vectorOfWeakReferences = []
996                for i in range(monster.VectorOfWeakReferencesLength()):
997                    self.vectorOfWeakReferences.append(monster.VectorOfWeakReferences(i))
998            else:
999                self.vectorOfWeakReferences = monster.VectorOfWeakReferencesAsNumpy()
1000        if not monster.VectorOfStrongReferrablesIsNone():
1001            self.vectorOfStrongReferrables = []
1002            for i in range(monster.VectorOfStrongReferrablesLength()):
1003                if monster.VectorOfStrongReferrables(i) is None:
1004                    self.vectorOfStrongReferrables.append(None)
1005                else:
1006                    referrable_ = MyGame.Example.Referrable.ReferrableT.InitFromObj(monster.VectorOfStrongReferrables(i))
1007                    self.vectorOfStrongReferrables.append(referrable_)
1008        self.coOwningReference = monster.CoOwningReference()
1009        if not monster.VectorOfCoOwningReferencesIsNone():
1010            if np is None:
1011                self.vectorOfCoOwningReferences = []
1012                for i in range(monster.VectorOfCoOwningReferencesLength()):
1013                    self.vectorOfCoOwningReferences.append(monster.VectorOfCoOwningReferences(i))
1014            else:
1015                self.vectorOfCoOwningReferences = monster.VectorOfCoOwningReferencesAsNumpy()
1016        self.nonOwningReference = monster.NonOwningReference()
1017        if not monster.VectorOfNonOwningReferencesIsNone():
1018            if np is None:
1019                self.vectorOfNonOwningReferences = []
1020                for i in range(monster.VectorOfNonOwningReferencesLength()):
1021                    self.vectorOfNonOwningReferences.append(monster.VectorOfNonOwningReferences(i))
1022            else:
1023                self.vectorOfNonOwningReferences = monster.VectorOfNonOwningReferencesAsNumpy()
1024        self.anyUniqueType = monster.AnyUniqueType()
1025        self.anyUnique = MyGame.Example.AnyUniqueAliases.AnyUniqueAliasesCreator(self.anyUniqueType, monster.AnyUnique())
1026        self.anyAmbiguousType = monster.AnyAmbiguousType()
1027        self.anyAmbiguous = MyGame.Example.AnyAmbiguousAliases.AnyAmbiguousAliasesCreator(self.anyAmbiguousType, monster.AnyAmbiguous())
1028        if not monster.VectorOfEnumsIsNone():
1029            if np is None:
1030                self.vectorOfEnums = []
1031                for i in range(monster.VectorOfEnumsLength()):
1032                    self.vectorOfEnums.append(monster.VectorOfEnums(i))
1033            else:
1034                self.vectorOfEnums = monster.VectorOfEnumsAsNumpy()
1035        self.signedEnum = monster.SignedEnum()
1036
1037    # MonsterT
1038    def Pack(self, builder):
1039        if self.name is not None:
1040            name = builder.CreateString(self.name)
1041        if self.inventory is not None:
1042            if np is not None and type(self.inventory) is np.ndarray:
1043                inventory = builder.CreateNumpyVector(self.inventory)
1044            else:
1045                MonsterStartInventoryVector(builder, len(self.inventory))
1046                for i in reversed(range(len(self.inventory))):
1047                    builder.PrependUint8(self.inventory[i])
1048                inventory = builder.EndVector(len(self.inventory))
1049        if self.test is not None:
1050            test = self.test.Pack(builder)
1051        if self.test4 is not None:
1052            MonsterStartTest4Vector(builder, len(self.test4))
1053            for i in reversed(range(len(self.test4))):
1054                self.test4[i].Pack(builder)
1055            test4 = builder.EndVector(len(self.test4))
1056        if self.testarrayofstring is not None:
1057            testarrayofstringlist = []
1058            for i in range(len(self.testarrayofstring)):
1059                testarrayofstringlist.append(builder.CreateString(self.testarrayofstring[i]))
1060            MonsterStartTestarrayofstringVector(builder, len(self.testarrayofstring))
1061            for i in reversed(range(len(self.testarrayofstring))):
1062                builder.PrependUOffsetTRelative(testarrayofstringlist[i])
1063            testarrayofstring = builder.EndVector(len(self.testarrayofstring))
1064        if self.testarrayoftables is not None:
1065            testarrayoftableslist = []
1066            for i in range(len(self.testarrayoftables)):
1067                testarrayoftableslist.append(self.testarrayoftables[i].Pack(builder))
1068            MonsterStartTestarrayoftablesVector(builder, len(self.testarrayoftables))
1069            for i in reversed(range(len(self.testarrayoftables))):
1070                builder.PrependUOffsetTRelative(testarrayoftableslist[i])
1071            testarrayoftables = builder.EndVector(len(self.testarrayoftables))
1072        if self.enemy is not None:
1073            enemy = self.enemy.Pack(builder)
1074        if self.testnestedflatbuffer is not None:
1075            if np is not None and type(self.testnestedflatbuffer) is np.ndarray:
1076                testnestedflatbuffer = builder.CreateNumpyVector(self.testnestedflatbuffer)
1077            else:
1078                MonsterStartTestnestedflatbufferVector(builder, len(self.testnestedflatbuffer))
1079                for i in reversed(range(len(self.testnestedflatbuffer))):
1080                    builder.PrependUint8(self.testnestedflatbuffer[i])
1081                testnestedflatbuffer = builder.EndVector(len(self.testnestedflatbuffer))
1082        if self.testempty is not None:
1083            testempty = self.testempty.Pack(builder)
1084        if self.testarrayofbools is not None:
1085            if np is not None and type(self.testarrayofbools) is np.ndarray:
1086                testarrayofbools = builder.CreateNumpyVector(self.testarrayofbools)
1087            else:
1088                MonsterStartTestarrayofboolsVector(builder, len(self.testarrayofbools))
1089                for i in reversed(range(len(self.testarrayofbools))):
1090                    builder.PrependBool(self.testarrayofbools[i])
1091                testarrayofbools = builder.EndVector(len(self.testarrayofbools))
1092        if self.testarrayofstring2 is not None:
1093            testarrayofstring2list = []
1094            for i in range(len(self.testarrayofstring2)):
1095                testarrayofstring2list.append(builder.CreateString(self.testarrayofstring2[i]))
1096            MonsterStartTestarrayofstring2Vector(builder, len(self.testarrayofstring2))
1097            for i in reversed(range(len(self.testarrayofstring2))):
1098                builder.PrependUOffsetTRelative(testarrayofstring2list[i])
1099            testarrayofstring2 = builder.EndVector(len(self.testarrayofstring2))
1100        if self.testarrayofsortedstruct is not None:
1101            MonsterStartTestarrayofsortedstructVector(builder, len(self.testarrayofsortedstruct))
1102            for i in reversed(range(len(self.testarrayofsortedstruct))):
1103                self.testarrayofsortedstruct[i].Pack(builder)
1104            testarrayofsortedstruct = builder.EndVector(len(self.testarrayofsortedstruct))
1105        if self.flex is not None:
1106            if np is not None and type(self.flex) is np.ndarray:
1107                flex = builder.CreateNumpyVector(self.flex)
1108            else:
1109                MonsterStartFlexVector(builder, len(self.flex))
1110                for i in reversed(range(len(self.flex))):
1111                    builder.PrependUint8(self.flex[i])
1112                flex = builder.EndVector(len(self.flex))
1113        if self.test5 is not None:
1114            MonsterStartTest5Vector(builder, len(self.test5))
1115            for i in reversed(range(len(self.test5))):
1116                self.test5[i].Pack(builder)
1117            test5 = builder.EndVector(len(self.test5))
1118        if self.vectorOfLongs is not None:
1119            if np is not None and type(self.vectorOfLongs) is np.ndarray:
1120                vectorOfLongs = builder.CreateNumpyVector(self.vectorOfLongs)
1121            else:
1122                MonsterStartVectorOfLongsVector(builder, len(self.vectorOfLongs))
1123                for i in reversed(range(len(self.vectorOfLongs))):
1124                    builder.PrependInt64(self.vectorOfLongs[i])
1125                vectorOfLongs = builder.EndVector(len(self.vectorOfLongs))
1126        if self.vectorOfDoubles is not None:
1127            if np is not None and type(self.vectorOfDoubles) is np.ndarray:
1128                vectorOfDoubles = builder.CreateNumpyVector(self.vectorOfDoubles)
1129            else:
1130                MonsterStartVectorOfDoublesVector(builder, len(self.vectorOfDoubles))
1131                for i in reversed(range(len(self.vectorOfDoubles))):
1132                    builder.PrependFloat64(self.vectorOfDoubles[i])
1133                vectorOfDoubles = builder.EndVector(len(self.vectorOfDoubles))
1134        if self.parentNamespaceTest is not None:
1135            parentNamespaceTest = self.parentNamespaceTest.Pack(builder)
1136        if self.vectorOfReferrables is not None:
1137            vectorOfReferrableslist = []
1138            for i in range(len(self.vectorOfReferrables)):
1139                vectorOfReferrableslist.append(self.vectorOfReferrables[i].Pack(builder))
1140            MonsterStartVectorOfReferrablesVector(builder, len(self.vectorOfReferrables))
1141            for i in reversed(range(len(self.vectorOfReferrables))):
1142                builder.PrependUOffsetTRelative(vectorOfReferrableslist[i])
1143            vectorOfReferrables = builder.EndVector(len(self.vectorOfReferrables))
1144        if self.vectorOfWeakReferences is not None:
1145            if np is not None and type(self.vectorOfWeakReferences) is np.ndarray:
1146                vectorOfWeakReferences = builder.CreateNumpyVector(self.vectorOfWeakReferences)
1147            else:
1148                MonsterStartVectorOfWeakReferencesVector(builder, len(self.vectorOfWeakReferences))
1149                for i in reversed(range(len(self.vectorOfWeakReferences))):
1150                    builder.PrependUint64(self.vectorOfWeakReferences[i])
1151                vectorOfWeakReferences = builder.EndVector(len(self.vectorOfWeakReferences))
1152        if self.vectorOfStrongReferrables is not None:
1153            vectorOfStrongReferrableslist = []
1154            for i in range(len(self.vectorOfStrongReferrables)):
1155                vectorOfStrongReferrableslist.append(self.vectorOfStrongReferrables[i].Pack(builder))
1156            MonsterStartVectorOfStrongReferrablesVector(builder, len(self.vectorOfStrongReferrables))
1157            for i in reversed(range(len(self.vectorOfStrongReferrables))):
1158                builder.PrependUOffsetTRelative(vectorOfStrongReferrableslist[i])
1159            vectorOfStrongReferrables = builder.EndVector(len(self.vectorOfStrongReferrables))
1160        if self.vectorOfCoOwningReferences is not None:
1161            if np is not None and type(self.vectorOfCoOwningReferences) is np.ndarray:
1162                vectorOfCoOwningReferences = builder.CreateNumpyVector(self.vectorOfCoOwningReferences)
1163            else:
1164                MonsterStartVectorOfCoOwningReferencesVector(builder, len(self.vectorOfCoOwningReferences))
1165                for i in reversed(range(len(self.vectorOfCoOwningReferences))):
1166                    builder.PrependUint64(self.vectorOfCoOwningReferences[i])
1167                vectorOfCoOwningReferences = builder.EndVector(len(self.vectorOfCoOwningReferences))
1168        if self.vectorOfNonOwningReferences is not None:
1169            if np is not None and type(self.vectorOfNonOwningReferences) is np.ndarray:
1170                vectorOfNonOwningReferences = builder.CreateNumpyVector(self.vectorOfNonOwningReferences)
1171            else:
1172                MonsterStartVectorOfNonOwningReferencesVector(builder, len(self.vectorOfNonOwningReferences))
1173                for i in reversed(range(len(self.vectorOfNonOwningReferences))):
1174                    builder.PrependUint64(self.vectorOfNonOwningReferences[i])
1175                vectorOfNonOwningReferences = builder.EndVector(len(self.vectorOfNonOwningReferences))
1176        if self.anyUnique is not None:
1177            anyUnique = self.anyUnique.Pack(builder)
1178        if self.anyAmbiguous is not None:
1179            anyAmbiguous = self.anyAmbiguous.Pack(builder)
1180        if self.vectorOfEnums is not None:
1181            if np is not None and type(self.vectorOfEnums) is np.ndarray:
1182                vectorOfEnums = builder.CreateNumpyVector(self.vectorOfEnums)
1183            else:
1184                MonsterStartVectorOfEnumsVector(builder, len(self.vectorOfEnums))
1185                for i in reversed(range(len(self.vectorOfEnums))):
1186                    builder.PrependUint8(self.vectorOfEnums[i])
1187                vectorOfEnums = builder.EndVector(len(self.vectorOfEnums))
1188        MonsterStart(builder)
1189        if self.pos is not None:
1190            pos = self.pos.Pack(builder)
1191            MonsterAddPos(builder, pos)
1192        MonsterAddMana(builder, self.mana)
1193        MonsterAddHp(builder, self.hp)
1194        if self.name is not None:
1195            MonsterAddName(builder, name)
1196        if self.inventory is not None:
1197            MonsterAddInventory(builder, inventory)
1198        MonsterAddColor(builder, self.color)
1199        MonsterAddTestType(builder, self.testType)
1200        if self.test is not None:
1201            MonsterAddTest(builder, test)
1202        if self.test4 is not None:
1203            MonsterAddTest4(builder, test4)
1204        if self.testarrayofstring is not None:
1205            MonsterAddTestarrayofstring(builder, testarrayofstring)
1206        if self.testarrayoftables is not None:
1207            MonsterAddTestarrayoftables(builder, testarrayoftables)
1208        if self.enemy is not None:
1209            MonsterAddEnemy(builder, enemy)
1210        if self.testnestedflatbuffer is not None:
1211            MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer)
1212        if self.testempty is not None:
1213            MonsterAddTestempty(builder, testempty)
1214        MonsterAddTestbool(builder, self.testbool)
1215        MonsterAddTesthashs32Fnv1(builder, self.testhashs32Fnv1)
1216        MonsterAddTesthashu32Fnv1(builder, self.testhashu32Fnv1)
1217        MonsterAddTesthashs64Fnv1(builder, self.testhashs64Fnv1)
1218        MonsterAddTesthashu64Fnv1(builder, self.testhashu64Fnv1)
1219        MonsterAddTesthashs32Fnv1a(builder, self.testhashs32Fnv1a)
1220        MonsterAddTesthashu32Fnv1a(builder, self.testhashu32Fnv1a)
1221        MonsterAddTesthashs64Fnv1a(builder, self.testhashs64Fnv1a)
1222        MonsterAddTesthashu64Fnv1a(builder, self.testhashu64Fnv1a)
1223        if self.testarrayofbools is not None:
1224            MonsterAddTestarrayofbools(builder, testarrayofbools)
1225        MonsterAddTestf(builder, self.testf)
1226        MonsterAddTestf2(builder, self.testf2)
1227        MonsterAddTestf3(builder, self.testf3)
1228        if self.testarrayofstring2 is not None:
1229            MonsterAddTestarrayofstring2(builder, testarrayofstring2)
1230        if self.testarrayofsortedstruct is not None:
1231            MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct)
1232        if self.flex is not None:
1233            MonsterAddFlex(builder, flex)
1234        if self.test5 is not None:
1235            MonsterAddTest5(builder, test5)
1236        if self.vectorOfLongs is not None:
1237            MonsterAddVectorOfLongs(builder, vectorOfLongs)
1238        if self.vectorOfDoubles is not None:
1239            MonsterAddVectorOfDoubles(builder, vectorOfDoubles)
1240        if self.parentNamespaceTest is not None:
1241            MonsterAddParentNamespaceTest(builder, parentNamespaceTest)
1242        if self.vectorOfReferrables is not None:
1243            MonsterAddVectorOfReferrables(builder, vectorOfReferrables)
1244        MonsterAddSingleWeakReference(builder, self.singleWeakReference)
1245        if self.vectorOfWeakReferences is not None:
1246            MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences)
1247        if self.vectorOfStrongReferrables is not None:
1248            MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables)
1249        MonsterAddCoOwningReference(builder, self.coOwningReference)
1250        if self.vectorOfCoOwningReferences is not None:
1251            MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences)
1252        MonsterAddNonOwningReference(builder, self.nonOwningReference)
1253        if self.vectorOfNonOwningReferences is not None:
1254            MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences)
1255        MonsterAddAnyUniqueType(builder, self.anyUniqueType)
1256        if self.anyUnique is not None:
1257            MonsterAddAnyUnique(builder, anyUnique)
1258        MonsterAddAnyAmbiguousType(builder, self.anyAmbiguousType)
1259        if self.anyAmbiguous is not None:
1260            MonsterAddAnyAmbiguous(builder, anyAmbiguous)
1261        if self.vectorOfEnums is not None:
1262            MonsterAddVectorOfEnums(builder, vectorOfEnums)
1263        MonsterAddSignedEnum(builder, self.signedEnum)
1264        monster = MonsterEnd(builder)
1265        return monster
1266