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 GetRootAs(cls, buf, offset=0):
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 GetRootAsMonster(cls, buf, offset=0):
22        """This method is deprecated. Please switch to GetRootAs."""
23        return cls.GetRootAs(buf, offset)
24    @classmethod
25    def MonsterBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
26        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x4F\x4E\x53", size_prefixed=size_prefixed)
27
28    # Monster
29    def Init(self, buf, pos):
30        self._tab = flatbuffers.table.Table(buf, pos)
31
32    # Monster
33    def Pos(self):
34        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
35        if o != 0:
36            x = o + self._tab.Pos
37            from MyGame.Example.Vec3 import Vec3
38            obj = Vec3()
39            obj.Init(self._tab.Bytes, x)
40            return obj
41        return None
42
43    # Monster
44    def Mana(self):
45        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
46        if o != 0:
47            return self._tab.Get(flatbuffers.number_types.Int16Flags, o + self._tab.Pos)
48        return 150
49
50    # Monster
51    def Hp(self):
52        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
53        if o != 0:
54            return self._tab.Get(flatbuffers.number_types.Int16Flags, o + self._tab.Pos)
55        return 100
56
57    # Monster
58    def Name(self):
59        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
60        if o != 0:
61            return self._tab.String(o + self._tab.Pos)
62        return None
63
64    # Monster
65    def Inventory(self, j):
66        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
67        if o != 0:
68            a = self._tab.Vector(o)
69            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
70        return 0
71
72    # Monster
73    def InventoryAsNumpy(self):
74        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
75        if o != 0:
76            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
77        return 0
78
79    # Monster
80    def InventoryLength(self):
81        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
82        if o != 0:
83            return self._tab.VectorLen(o)
84        return 0
85
86    # Monster
87    def InventoryIsNone(self):
88        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
89        return o == 0
90
91    # Monster
92    def Color(self):
93        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
94        if o != 0:
95            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
96        return 8
97
98    # Monster
99    def TestType(self):
100        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
101        if o != 0:
102            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
103        return 0
104
105    # Monster
106    def Test(self):
107        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
108        if o != 0:
109            from flatbuffers.table import Table
110            obj = Table(bytearray(), 0)
111            self._tab.Union(obj, o)
112            return obj
113        return None
114
115    # Monster
116    def Test4(self, j):
117        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
118        if o != 0:
119            x = self._tab.Vector(o)
120            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
121            from MyGame.Example.Test import Test
122            obj = Test()
123            obj.Init(self._tab.Bytes, x)
124            return obj
125        return None
126
127    # Monster
128    def Test4Length(self):
129        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
130        if o != 0:
131            return self._tab.VectorLen(o)
132        return 0
133
134    # Monster
135    def Test4IsNone(self):
136        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
137        return o == 0
138
139    # Monster
140    def Testarrayofstring(self, j):
141        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
142        if o != 0:
143            a = self._tab.Vector(o)
144            return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
145        return ""
146
147    # Monster
148    def TestarrayofstringLength(self):
149        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
150        if o != 0:
151            return self._tab.VectorLen(o)
152        return 0
153
154    # Monster
155    def TestarrayofstringIsNone(self):
156        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
157        return o == 0
158
159    # an example documentation comment: this will end up in the generated code
160    # multiline too
161    # Monster
162    def Testarrayoftables(self, j):
163        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
164        if o != 0:
165            x = self._tab.Vector(o)
166            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
167            x = self._tab.Indirect(x)
168            from MyGame.Example.Monster import Monster
169            obj = Monster()
170            obj.Init(self._tab.Bytes, x)
171            return obj
172        return None
173
174    # Monster
175    def TestarrayoftablesLength(self):
176        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
177        if o != 0:
178            return self._tab.VectorLen(o)
179        return 0
180
181    # Monster
182    def TestarrayoftablesIsNone(self):
183        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
184        return o == 0
185
186    # Monster
187    def Enemy(self):
188        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
189        if o != 0:
190            x = self._tab.Indirect(o + self._tab.Pos)
191            from MyGame.Example.Monster import Monster
192            obj = Monster()
193            obj.Init(self._tab.Bytes, x)
194            return obj
195        return None
196
197    # Monster
198    def Testnestedflatbuffer(self, j):
199        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
200        if o != 0:
201            a = self._tab.Vector(o)
202            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
203        return 0
204
205    # Monster
206    def TestnestedflatbufferAsNumpy(self):
207        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
208        if o != 0:
209            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
210        return 0
211
212    # Monster
213    def TestnestedflatbufferNestedRoot(self):
214        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
215        if o != 0:
216            from MyGame.Example.Monster import Monster
217            return Monster.GetRootAs(self._tab.Bytes, self._tab.Vector(o))
218        return 0
219
220    # Monster
221    def TestnestedflatbufferLength(self):
222        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
223        if o != 0:
224            return self._tab.VectorLen(o)
225        return 0
226
227    # Monster
228    def TestnestedflatbufferIsNone(self):
229        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
230        return o == 0
231
232    # Monster
233    def Testempty(self):
234        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
235        if o != 0:
236            x = self._tab.Indirect(o + self._tab.Pos)
237            from MyGame.Example.Stat import Stat
238            obj = Stat()
239            obj.Init(self._tab.Bytes, x)
240            return obj
241        return None
242
243    # Monster
244    def Testbool(self):
245        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
246        if o != 0:
247            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
248        return False
249
250    # Monster
251    def Testhashs32Fnv1(self):
252        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
253        if o != 0:
254            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
255        return 0
256
257    # Monster
258    def Testhashu32Fnv1(self):
259        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(38))
260        if o != 0:
261            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
262        return 0
263
264    # Monster
265    def Testhashs64Fnv1(self):
266        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(40))
267        if o != 0:
268            return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
269        return 0
270
271    # Monster
272    def Testhashu64Fnv1(self):
273        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(42))
274        if o != 0:
275            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
276        return 0
277
278    # Monster
279    def Testhashs32Fnv1a(self):
280        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(44))
281        if o != 0:
282            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
283        return 0
284
285    # Monster
286    def Testhashu32Fnv1a(self):
287        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(46))
288        if o != 0:
289            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
290        return 0
291
292    # Monster
293    def Testhashs64Fnv1a(self):
294        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(48))
295        if o != 0:
296            return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
297        return 0
298
299    # Monster
300    def Testhashu64Fnv1a(self):
301        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(50))
302        if o != 0:
303            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
304        return 0
305
306    # Monster
307    def Testarrayofbools(self, j):
308        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
309        if o != 0:
310            a = self._tab.Vector(o)
311            return self._tab.Get(flatbuffers.number_types.BoolFlags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
312        return 0
313
314    # Monster
315    def TestarrayofboolsAsNumpy(self):
316        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
317        if o != 0:
318            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.BoolFlags, o)
319        return 0
320
321    # Monster
322    def TestarrayofboolsLength(self):
323        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
324        if o != 0:
325            return self._tab.VectorLen(o)
326        return 0
327
328    # Monster
329    def TestarrayofboolsIsNone(self):
330        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
331        return o == 0
332
333    # Monster
334    def Testf(self):
335        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(54))
336        if o != 0:
337            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
338        return 3.14159
339
340    # Monster
341    def Testf2(self):
342        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(56))
343        if o != 0:
344            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
345        return 3.0
346
347    # Monster
348    def Testf3(self):
349        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(58))
350        if o != 0:
351            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
352        return 0.0
353
354    # Monster
355    def Testarrayofstring2(self, j):
356        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(60))
357        if o != 0:
358            a = self._tab.Vector(o)
359            return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
360        return ""
361
362    # Monster
363    def Testarrayofstring2Length(self):
364        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(60))
365        if o != 0:
366            return self._tab.VectorLen(o)
367        return 0
368
369    # Monster
370    def Testarrayofstring2IsNone(self):
371        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(60))
372        return o == 0
373
374    # Monster
375    def Testarrayofsortedstruct(self, j):
376        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(62))
377        if o != 0:
378            x = self._tab.Vector(o)
379            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 8
380            from MyGame.Example.Ability import Ability
381            obj = Ability()
382            obj.Init(self._tab.Bytes, x)
383            return obj
384        return None
385
386    # Monster
387    def TestarrayofsortedstructLength(self):
388        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(62))
389        if o != 0:
390            return self._tab.VectorLen(o)
391        return 0
392
393    # Monster
394    def TestarrayofsortedstructIsNone(self):
395        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(62))
396        return o == 0
397
398    # Monster
399    def Flex(self, j):
400        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
401        if o != 0:
402            a = self._tab.Vector(o)
403            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
404        return 0
405
406    # Monster
407    def FlexAsNumpy(self):
408        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
409        if o != 0:
410            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
411        return 0
412
413    # Monster
414    def FlexLength(self):
415        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
416        if o != 0:
417            return self._tab.VectorLen(o)
418        return 0
419
420    # Monster
421    def FlexIsNone(self):
422        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
423        return o == 0
424
425    # Monster
426    def Test5(self, j):
427        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(66))
428        if o != 0:
429            x = self._tab.Vector(o)
430            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
431            from MyGame.Example.Test import Test
432            obj = Test()
433            obj.Init(self._tab.Bytes, x)
434            return obj
435        return None
436
437    # Monster
438    def Test5Length(self):
439        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(66))
440        if o != 0:
441            return self._tab.VectorLen(o)
442        return 0
443
444    # Monster
445    def Test5IsNone(self):
446        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(66))
447        return o == 0
448
449    # Monster
450    def VectorOfLongs(self, j):
451        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
452        if o != 0:
453            a = self._tab.Vector(o)
454            return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
455        return 0
456
457    # Monster
458    def VectorOfLongsAsNumpy(self):
459        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
460        if o != 0:
461            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o)
462        return 0
463
464    # Monster
465    def VectorOfLongsLength(self):
466        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
467        if o != 0:
468            return self._tab.VectorLen(o)
469        return 0
470
471    # Monster
472    def VectorOfLongsIsNone(self):
473        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
474        return o == 0
475
476    # Monster
477    def VectorOfDoubles(self, j):
478        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
479        if o != 0:
480            a = self._tab.Vector(o)
481            return self._tab.Get(flatbuffers.number_types.Float64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
482        return 0
483
484    # Monster
485    def VectorOfDoublesAsNumpy(self):
486        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
487        if o != 0:
488            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float64Flags, o)
489        return 0
490
491    # Monster
492    def VectorOfDoublesLength(self):
493        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
494        if o != 0:
495            return self._tab.VectorLen(o)
496        return 0
497
498    # Monster
499    def VectorOfDoublesIsNone(self):
500        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
501        return o == 0
502
503    # Monster
504    def ParentNamespaceTest(self):
505        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(72))
506        if o != 0:
507            x = self._tab.Indirect(o + self._tab.Pos)
508            from MyGame.InParentNamespace import InParentNamespace
509            obj = InParentNamespace()
510            obj.Init(self._tab.Bytes, x)
511            return obj
512        return None
513
514    # Monster
515    def VectorOfReferrables(self, j):
516        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(74))
517        if o != 0:
518            x = self._tab.Vector(o)
519            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
520            x = self._tab.Indirect(x)
521            from MyGame.Example.Referrable import Referrable
522            obj = Referrable()
523            obj.Init(self._tab.Bytes, x)
524            return obj
525        return None
526
527    # Monster
528    def VectorOfReferrablesLength(self):
529        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(74))
530        if o != 0:
531            return self._tab.VectorLen(o)
532        return 0
533
534    # Monster
535    def VectorOfReferrablesIsNone(self):
536        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(74))
537        return o == 0
538
539    # Monster
540    def SingleWeakReference(self):
541        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(76))
542        if o != 0:
543            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
544        return 0
545
546    # Monster
547    def VectorOfWeakReferences(self, j):
548        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(78))
549        if o != 0:
550            a = self._tab.Vector(o)
551            return self._tab.Get(flatbuffers.number_types.Uint64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
552        return 0
553
554    # Monster
555    def VectorOfWeakReferencesAsNumpy(self):
556        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(78))
557        if o != 0:
558            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint64Flags, o)
559        return 0
560
561    # Monster
562    def VectorOfWeakReferencesLength(self):
563        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(78))
564        if o != 0:
565            return self._tab.VectorLen(o)
566        return 0
567
568    # Monster
569    def VectorOfWeakReferencesIsNone(self):
570        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(78))
571        return o == 0
572
573    # Monster
574    def VectorOfStrongReferrables(self, j):
575        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(80))
576        if o != 0:
577            x = self._tab.Vector(o)
578            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
579            x = self._tab.Indirect(x)
580            from MyGame.Example.Referrable import Referrable
581            obj = Referrable()
582            obj.Init(self._tab.Bytes, x)
583            return obj
584        return None
585
586    # Monster
587    def VectorOfStrongReferrablesLength(self):
588        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(80))
589        if o != 0:
590            return self._tab.VectorLen(o)
591        return 0
592
593    # Monster
594    def VectorOfStrongReferrablesIsNone(self):
595        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(80))
596        return o == 0
597
598    # Monster
599    def CoOwningReference(self):
600        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(82))
601        if o != 0:
602            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
603        return 0
604
605    # Monster
606    def VectorOfCoOwningReferences(self, j):
607        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(84))
608        if o != 0:
609            a = self._tab.Vector(o)
610            return self._tab.Get(flatbuffers.number_types.Uint64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
611        return 0
612
613    # Monster
614    def VectorOfCoOwningReferencesAsNumpy(self):
615        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(84))
616        if o != 0:
617            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint64Flags, o)
618        return 0
619
620    # Monster
621    def VectorOfCoOwningReferencesLength(self):
622        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(84))
623        if o != 0:
624            return self._tab.VectorLen(o)
625        return 0
626
627    # Monster
628    def VectorOfCoOwningReferencesIsNone(self):
629        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(84))
630        return o == 0
631
632    # Monster
633    def NonOwningReference(self):
634        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(86))
635        if o != 0:
636            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
637        return 0
638
639    # Monster
640    def VectorOfNonOwningReferences(self, j):
641        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
642        if o != 0:
643            a = self._tab.Vector(o)
644            return self._tab.Get(flatbuffers.number_types.Uint64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
645        return 0
646
647    # Monster
648    def VectorOfNonOwningReferencesAsNumpy(self):
649        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
650        if o != 0:
651            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint64Flags, o)
652        return 0
653
654    # Monster
655    def VectorOfNonOwningReferencesLength(self):
656        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
657        if o != 0:
658            return self._tab.VectorLen(o)
659        return 0
660
661    # Monster
662    def VectorOfNonOwningReferencesIsNone(self):
663        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
664        return o == 0
665
666    # Monster
667    def AnyUniqueType(self):
668        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(90))
669        if o != 0:
670            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
671        return 0
672
673    # Monster
674    def AnyUnique(self):
675        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(92))
676        if o != 0:
677            from flatbuffers.table import Table
678            obj = Table(bytearray(), 0)
679            self._tab.Union(obj, o)
680            return obj
681        return None
682
683    # Monster
684    def AnyAmbiguousType(self):
685        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(94))
686        if o != 0:
687            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
688        return 0
689
690    # Monster
691    def AnyAmbiguous(self):
692        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(96))
693        if o != 0:
694            from flatbuffers.table import Table
695            obj = Table(bytearray(), 0)
696            self._tab.Union(obj, o)
697            return obj
698        return None
699
700    # Monster
701    def VectorOfEnums(self, j):
702        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
703        if o != 0:
704            a = self._tab.Vector(o)
705            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
706        return 0
707
708    # Monster
709    def VectorOfEnumsAsNumpy(self):
710        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
711        if o != 0:
712            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
713        return 0
714
715    # Monster
716    def VectorOfEnumsLength(self):
717        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
718        if o != 0:
719            return self._tab.VectorLen(o)
720        return 0
721
722    # Monster
723    def VectorOfEnumsIsNone(self):
724        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
725        return o == 0
726
727    # Monster
728    def SignedEnum(self):
729        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(100))
730        if o != 0:
731            return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
732        return -1
733
734    # Monster
735    def Testrequirednestedflatbuffer(self, j):
736        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
737        if o != 0:
738            a = self._tab.Vector(o)
739            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
740        return 0
741
742    # Monster
743    def TestrequirednestedflatbufferAsNumpy(self):
744        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
745        if o != 0:
746            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
747        return 0
748
749    # Monster
750    def TestrequirednestedflatbufferNestedRoot(self):
751        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
752        if o != 0:
753            from MyGame.Example.Monster import Monster
754            return Monster.GetRootAs(self._tab.Bytes, self._tab.Vector(o))
755        return 0
756
757    # Monster
758    def TestrequirednestedflatbufferLength(self):
759        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
760        if o != 0:
761            return self._tab.VectorLen(o)
762        return 0
763
764    # Monster
765    def TestrequirednestedflatbufferIsNone(self):
766        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
767        return o == 0
768
769    # Monster
770    def ScalarKeySortedTables(self, j):
771        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(104))
772        if o != 0:
773            x = self._tab.Vector(o)
774            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
775            x = self._tab.Indirect(x)
776            from MyGame.Example.Stat import Stat
777            obj = Stat()
778            obj.Init(self._tab.Bytes, x)
779            return obj
780        return None
781
782    # Monster
783    def ScalarKeySortedTablesLength(self):
784        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(104))
785        if o != 0:
786            return self._tab.VectorLen(o)
787        return 0
788
789    # Monster
790    def ScalarKeySortedTablesIsNone(self):
791        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(104))
792        return o == 0
793
794def Start(builder): builder.StartObject(51)
795def MonsterStart(builder):
796    """This method is deprecated. Please switch to Start."""
797    return Start(builder)
798def AddPos(builder, pos): builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pos), 0)
799def MonsterAddPos(builder, pos):
800    """This method is deprecated. Please switch to AddPos."""
801    return AddPos(builder, pos)
802def AddMana(builder, mana): builder.PrependInt16Slot(1, mana, 150)
803def MonsterAddMana(builder, mana):
804    """This method is deprecated. Please switch to AddMana."""
805    return AddMana(builder, mana)
806def AddHp(builder, hp): builder.PrependInt16Slot(2, hp, 100)
807def MonsterAddHp(builder, hp):
808    """This method is deprecated. Please switch to AddHp."""
809    return AddHp(builder, hp)
810def AddName(builder, name): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
811def MonsterAddName(builder, name):
812    """This method is deprecated. Please switch to AddName."""
813    return AddName(builder, name)
814def AddInventory(builder, inventory): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(inventory), 0)
815def MonsterAddInventory(builder, inventory):
816    """This method is deprecated. Please switch to AddInventory."""
817    return AddInventory(builder, inventory)
818def StartInventoryVector(builder, numElems): return builder.StartVector(1, numElems, 1)
819def MonsterStartInventoryVector(builder, numElems):
820    """This method is deprecated. Please switch to Start."""
821    return StartInventoryVector(builder, numElems)
822def AddColor(builder, color): builder.PrependUint8Slot(6, color, 8)
823def MonsterAddColor(builder, color):
824    """This method is deprecated. Please switch to AddColor."""
825    return AddColor(builder, color)
826def AddTestType(builder, testType): builder.PrependUint8Slot(7, testType, 0)
827def MonsterAddTestType(builder, testType):
828    """This method is deprecated. Please switch to AddTestType."""
829    return AddTestType(builder, testType)
830def AddTest(builder, test): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(test), 0)
831def MonsterAddTest(builder, test):
832    """This method is deprecated. Please switch to AddTest."""
833    return AddTest(builder, test)
834def AddTest4(builder, test4): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(test4), 0)
835def MonsterAddTest4(builder, test4):
836    """This method is deprecated. Please switch to AddTest4."""
837    return AddTest4(builder, test4)
838def StartTest4Vector(builder, numElems): return builder.StartVector(4, numElems, 2)
839def MonsterStartTest4Vector(builder, numElems):
840    """This method is deprecated. Please switch to Start."""
841    return StartTest4Vector(builder, numElems)
842def AddTestarrayofstring(builder, testarrayofstring): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring), 0)
843def MonsterAddTestarrayofstring(builder, testarrayofstring):
844    """This method is deprecated. Please switch to AddTestarrayofstring."""
845    return AddTestarrayofstring(builder, testarrayofstring)
846def StartTestarrayofstringVector(builder, numElems): return builder.StartVector(4, numElems, 4)
847def MonsterStartTestarrayofstringVector(builder, numElems):
848    """This method is deprecated. Please switch to Start."""
849    return StartTestarrayofstringVector(builder, numElems)
850def AddTestarrayoftables(builder, testarrayoftables): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayoftables), 0)
851def MonsterAddTestarrayoftables(builder, testarrayoftables):
852    """This method is deprecated. Please switch to AddTestarrayoftables."""
853    return AddTestarrayoftables(builder, testarrayoftables)
854def StartTestarrayoftablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
855def MonsterStartTestarrayoftablesVector(builder, numElems):
856    """This method is deprecated. Please switch to Start."""
857    return StartTestarrayoftablesVector(builder, numElems)
858def AddEnemy(builder, enemy): builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(enemy), 0)
859def MonsterAddEnemy(builder, enemy):
860    """This method is deprecated. Please switch to AddEnemy."""
861    return AddEnemy(builder, enemy)
862def AddTestnestedflatbuffer(builder, testnestedflatbuffer): builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(testnestedflatbuffer), 0)
863def MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer):
864    """This method is deprecated. Please switch to AddTestnestedflatbuffer."""
865    return AddTestnestedflatbuffer(builder, testnestedflatbuffer)
866def StartTestnestedflatbufferVector(builder, numElems): return builder.StartVector(1, numElems, 1)
867def MonsterStartTestnestedflatbufferVector(builder, numElems):
868    """This method is deprecated. Please switch to Start."""
869    return StartTestnestedflatbufferVector(builder, numElems)
870def MakeVectorFromBytes(builder, bytes):
871    builder.StartVector(1, len(bytes), 1)
872    builder.head = builder.head - len(bytes)
873    builder.Bytes[builder.head : builder.head + len(bytes)] = bytes
874    return builder.EndVector()
875def MakeTestnestedflatbufferVectorFromBytes(builder, bytes):
876    builder.StartVector(1, len(bytes), 1)
877    builder.head = builder.head - len(bytes)
878    builder.Bytes[builder.head : builder.head + len(bytes)] = bytes
879    return builder.EndVector()
880def AddTestempty(builder, testempty): builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(testempty), 0)
881def MonsterAddTestempty(builder, testempty):
882    """This method is deprecated. Please switch to AddTestempty."""
883    return AddTestempty(builder, testempty)
884def AddTestbool(builder, testbool): builder.PrependBoolSlot(15, testbool, 0)
885def MonsterAddTestbool(builder, testbool):
886    """This method is deprecated. Please switch to AddTestbool."""
887    return AddTestbool(builder, testbool)
888def AddTesthashs32Fnv1(builder, testhashs32Fnv1): builder.PrependInt32Slot(16, testhashs32Fnv1, 0)
889def MonsterAddTesthashs32Fnv1(builder, testhashs32Fnv1):
890    """This method is deprecated. Please switch to AddTesthashs32Fnv1."""
891    return AddTesthashs32Fnv1(builder, testhashs32Fnv1)
892def AddTesthashu32Fnv1(builder, testhashu32Fnv1): builder.PrependUint32Slot(17, testhashu32Fnv1, 0)
893def MonsterAddTesthashu32Fnv1(builder, testhashu32Fnv1):
894    """This method is deprecated. Please switch to AddTesthashu32Fnv1."""
895    return AddTesthashu32Fnv1(builder, testhashu32Fnv1)
896def AddTesthashs64Fnv1(builder, testhashs64Fnv1): builder.PrependInt64Slot(18, testhashs64Fnv1, 0)
897def MonsterAddTesthashs64Fnv1(builder, testhashs64Fnv1):
898    """This method is deprecated. Please switch to AddTesthashs64Fnv1."""
899    return AddTesthashs64Fnv1(builder, testhashs64Fnv1)
900def AddTesthashu64Fnv1(builder, testhashu64Fnv1): builder.PrependUint64Slot(19, testhashu64Fnv1, 0)
901def MonsterAddTesthashu64Fnv1(builder, testhashu64Fnv1):
902    """This method is deprecated. Please switch to AddTesthashu64Fnv1."""
903    return AddTesthashu64Fnv1(builder, testhashu64Fnv1)
904def AddTesthashs32Fnv1a(builder, testhashs32Fnv1a): builder.PrependInt32Slot(20, testhashs32Fnv1a, 0)
905def MonsterAddTesthashs32Fnv1a(builder, testhashs32Fnv1a):
906    """This method is deprecated. Please switch to AddTesthashs32Fnv1a."""
907    return AddTesthashs32Fnv1a(builder, testhashs32Fnv1a)
908def AddTesthashu32Fnv1a(builder, testhashu32Fnv1a): builder.PrependUint32Slot(21, testhashu32Fnv1a, 0)
909def MonsterAddTesthashu32Fnv1a(builder, testhashu32Fnv1a):
910    """This method is deprecated. Please switch to AddTesthashu32Fnv1a."""
911    return AddTesthashu32Fnv1a(builder, testhashu32Fnv1a)
912def AddTesthashs64Fnv1a(builder, testhashs64Fnv1a): builder.PrependInt64Slot(22, testhashs64Fnv1a, 0)
913def MonsterAddTesthashs64Fnv1a(builder, testhashs64Fnv1a):
914    """This method is deprecated. Please switch to AddTesthashs64Fnv1a."""
915    return AddTesthashs64Fnv1a(builder, testhashs64Fnv1a)
916def AddTesthashu64Fnv1a(builder, testhashu64Fnv1a): builder.PrependUint64Slot(23, testhashu64Fnv1a, 0)
917def MonsterAddTesthashu64Fnv1a(builder, testhashu64Fnv1a):
918    """This method is deprecated. Please switch to AddTesthashu64Fnv1a."""
919    return AddTesthashu64Fnv1a(builder, testhashu64Fnv1a)
920def AddTestarrayofbools(builder, testarrayofbools): builder.PrependUOffsetTRelativeSlot(24, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofbools), 0)
921def MonsterAddTestarrayofbools(builder, testarrayofbools):
922    """This method is deprecated. Please switch to AddTestarrayofbools."""
923    return AddTestarrayofbools(builder, testarrayofbools)
924def StartTestarrayofboolsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
925def MonsterStartTestarrayofboolsVector(builder, numElems):
926    """This method is deprecated. Please switch to Start."""
927    return StartTestarrayofboolsVector(builder, numElems)
928def AddTestf(builder, testf): builder.PrependFloat32Slot(25, testf, 3.14159)
929def MonsterAddTestf(builder, testf):
930    """This method is deprecated. Please switch to AddTestf."""
931    return AddTestf(builder, testf)
932def AddTestf2(builder, testf2): builder.PrependFloat32Slot(26, testf2, 3.0)
933def MonsterAddTestf2(builder, testf2):
934    """This method is deprecated. Please switch to AddTestf2."""
935    return AddTestf2(builder, testf2)
936def AddTestf3(builder, testf3): builder.PrependFloat32Slot(27, testf3, 0.0)
937def MonsterAddTestf3(builder, testf3):
938    """This method is deprecated. Please switch to AddTestf3."""
939    return AddTestf3(builder, testf3)
940def AddTestarrayofstring2(builder, testarrayofstring2): builder.PrependUOffsetTRelativeSlot(28, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring2), 0)
941def MonsterAddTestarrayofstring2(builder, testarrayofstring2):
942    """This method is deprecated. Please switch to AddTestarrayofstring2."""
943    return AddTestarrayofstring2(builder, testarrayofstring2)
944def StartTestarrayofstring2Vector(builder, numElems): return builder.StartVector(4, numElems, 4)
945def MonsterStartTestarrayofstring2Vector(builder, numElems):
946    """This method is deprecated. Please switch to Start."""
947    return StartTestarrayofstring2Vector(builder, numElems)
948def AddTestarrayofsortedstruct(builder, testarrayofsortedstruct): builder.PrependUOffsetTRelativeSlot(29, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofsortedstruct), 0)
949def MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct):
950    """This method is deprecated. Please switch to AddTestarrayofsortedstruct."""
951    return AddTestarrayofsortedstruct(builder, testarrayofsortedstruct)
952def StartTestarrayofsortedstructVector(builder, numElems): return builder.StartVector(8, numElems, 4)
953def MonsterStartTestarrayofsortedstructVector(builder, numElems):
954    """This method is deprecated. Please switch to Start."""
955    return StartTestarrayofsortedstructVector(builder, numElems)
956def AddFlex(builder, flex): builder.PrependUOffsetTRelativeSlot(30, flatbuffers.number_types.UOffsetTFlags.py_type(flex), 0)
957def MonsterAddFlex(builder, flex):
958    """This method is deprecated. Please switch to AddFlex."""
959    return AddFlex(builder, flex)
960def StartFlexVector(builder, numElems): return builder.StartVector(1, numElems, 1)
961def MonsterStartFlexVector(builder, numElems):
962    """This method is deprecated. Please switch to Start."""
963    return StartFlexVector(builder, numElems)
964def AddTest5(builder, test5): builder.PrependUOffsetTRelativeSlot(31, flatbuffers.number_types.UOffsetTFlags.py_type(test5), 0)
965def MonsterAddTest5(builder, test5):
966    """This method is deprecated. Please switch to AddTest5."""
967    return AddTest5(builder, test5)
968def StartTest5Vector(builder, numElems): return builder.StartVector(4, numElems, 2)
969def MonsterStartTest5Vector(builder, numElems):
970    """This method is deprecated. Please switch to Start."""
971    return StartTest5Vector(builder, numElems)
972def AddVectorOfLongs(builder, vectorOfLongs): builder.PrependUOffsetTRelativeSlot(32, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfLongs), 0)
973def MonsterAddVectorOfLongs(builder, vectorOfLongs):
974    """This method is deprecated. Please switch to AddVectorOfLongs."""
975    return AddVectorOfLongs(builder, vectorOfLongs)
976def StartVectorOfLongsVector(builder, numElems): return builder.StartVector(8, numElems, 8)
977def MonsterStartVectorOfLongsVector(builder, numElems):
978    """This method is deprecated. Please switch to Start."""
979    return StartVectorOfLongsVector(builder, numElems)
980def AddVectorOfDoubles(builder, vectorOfDoubles): builder.PrependUOffsetTRelativeSlot(33, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfDoubles), 0)
981def MonsterAddVectorOfDoubles(builder, vectorOfDoubles):
982    """This method is deprecated. Please switch to AddVectorOfDoubles."""
983    return AddVectorOfDoubles(builder, vectorOfDoubles)
984def StartVectorOfDoublesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
985def MonsterStartVectorOfDoublesVector(builder, numElems):
986    """This method is deprecated. Please switch to Start."""
987    return StartVectorOfDoublesVector(builder, numElems)
988def AddParentNamespaceTest(builder, parentNamespaceTest): builder.PrependUOffsetTRelativeSlot(34, flatbuffers.number_types.UOffsetTFlags.py_type(parentNamespaceTest), 0)
989def MonsterAddParentNamespaceTest(builder, parentNamespaceTest):
990    """This method is deprecated. Please switch to AddParentNamespaceTest."""
991    return AddParentNamespaceTest(builder, parentNamespaceTest)
992def AddVectorOfReferrables(builder, vectorOfReferrables): builder.PrependUOffsetTRelativeSlot(35, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfReferrables), 0)
993def MonsterAddVectorOfReferrables(builder, vectorOfReferrables):
994    """This method is deprecated. Please switch to AddVectorOfReferrables."""
995    return AddVectorOfReferrables(builder, vectorOfReferrables)
996def StartVectorOfReferrablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
997def MonsterStartVectorOfReferrablesVector(builder, numElems):
998    """This method is deprecated. Please switch to Start."""
999    return StartVectorOfReferrablesVector(builder, numElems)
1000def AddSingleWeakReference(builder, singleWeakReference): builder.PrependUint64Slot(36, singleWeakReference, 0)
1001def MonsterAddSingleWeakReference(builder, singleWeakReference):
1002    """This method is deprecated. Please switch to AddSingleWeakReference."""
1003    return AddSingleWeakReference(builder, singleWeakReference)
1004def AddVectorOfWeakReferences(builder, vectorOfWeakReferences): builder.PrependUOffsetTRelativeSlot(37, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfWeakReferences), 0)
1005def MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences):
1006    """This method is deprecated. Please switch to AddVectorOfWeakReferences."""
1007    return AddVectorOfWeakReferences(builder, vectorOfWeakReferences)
1008def StartVectorOfWeakReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
1009def MonsterStartVectorOfWeakReferencesVector(builder, numElems):
1010    """This method is deprecated. Please switch to Start."""
1011    return StartVectorOfWeakReferencesVector(builder, numElems)
1012def AddVectorOfStrongReferrables(builder, vectorOfStrongReferrables): builder.PrependUOffsetTRelativeSlot(38, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfStrongReferrables), 0)
1013def MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables):
1014    """This method is deprecated. Please switch to AddVectorOfStrongReferrables."""
1015    return AddVectorOfStrongReferrables(builder, vectorOfStrongReferrables)
1016def StartVectorOfStrongReferrablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
1017def MonsterStartVectorOfStrongReferrablesVector(builder, numElems):
1018    """This method is deprecated. Please switch to Start."""
1019    return StartVectorOfStrongReferrablesVector(builder, numElems)
1020def AddCoOwningReference(builder, coOwningReference): builder.PrependUint64Slot(39, coOwningReference, 0)
1021def MonsterAddCoOwningReference(builder, coOwningReference):
1022    """This method is deprecated. Please switch to AddCoOwningReference."""
1023    return AddCoOwningReference(builder, coOwningReference)
1024def AddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences): builder.PrependUOffsetTRelativeSlot(40, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfCoOwningReferences), 0)
1025def MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences):
1026    """This method is deprecated. Please switch to AddVectorOfCoOwningReferences."""
1027    return AddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences)
1028def StartVectorOfCoOwningReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
1029def MonsterStartVectorOfCoOwningReferencesVector(builder, numElems):
1030    """This method is deprecated. Please switch to Start."""
1031    return StartVectorOfCoOwningReferencesVector(builder, numElems)
1032def AddNonOwningReference(builder, nonOwningReference): builder.PrependUint64Slot(41, nonOwningReference, 0)
1033def MonsterAddNonOwningReference(builder, nonOwningReference):
1034    """This method is deprecated. Please switch to AddNonOwningReference."""
1035    return AddNonOwningReference(builder, nonOwningReference)
1036def AddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences): builder.PrependUOffsetTRelativeSlot(42, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfNonOwningReferences), 0)
1037def MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences):
1038    """This method is deprecated. Please switch to AddVectorOfNonOwningReferences."""
1039    return AddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences)
1040def StartVectorOfNonOwningReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
1041def MonsterStartVectorOfNonOwningReferencesVector(builder, numElems):
1042    """This method is deprecated. Please switch to Start."""
1043    return StartVectorOfNonOwningReferencesVector(builder, numElems)
1044def AddAnyUniqueType(builder, anyUniqueType): builder.PrependUint8Slot(43, anyUniqueType, 0)
1045def MonsterAddAnyUniqueType(builder, anyUniqueType):
1046    """This method is deprecated. Please switch to AddAnyUniqueType."""
1047    return AddAnyUniqueType(builder, anyUniqueType)
1048def AddAnyUnique(builder, anyUnique): builder.PrependUOffsetTRelativeSlot(44, flatbuffers.number_types.UOffsetTFlags.py_type(anyUnique), 0)
1049def MonsterAddAnyUnique(builder, anyUnique):
1050    """This method is deprecated. Please switch to AddAnyUnique."""
1051    return AddAnyUnique(builder, anyUnique)
1052def AddAnyAmbiguousType(builder, anyAmbiguousType): builder.PrependUint8Slot(45, anyAmbiguousType, 0)
1053def MonsterAddAnyAmbiguousType(builder, anyAmbiguousType):
1054    """This method is deprecated. Please switch to AddAnyAmbiguousType."""
1055    return AddAnyAmbiguousType(builder, anyAmbiguousType)
1056def AddAnyAmbiguous(builder, anyAmbiguous): builder.PrependUOffsetTRelativeSlot(46, flatbuffers.number_types.UOffsetTFlags.py_type(anyAmbiguous), 0)
1057def MonsterAddAnyAmbiguous(builder, anyAmbiguous):
1058    """This method is deprecated. Please switch to AddAnyAmbiguous."""
1059    return AddAnyAmbiguous(builder, anyAmbiguous)
1060def AddVectorOfEnums(builder, vectorOfEnums): builder.PrependUOffsetTRelativeSlot(47, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfEnums), 0)
1061def MonsterAddVectorOfEnums(builder, vectorOfEnums):
1062    """This method is deprecated. Please switch to AddVectorOfEnums."""
1063    return AddVectorOfEnums(builder, vectorOfEnums)
1064def StartVectorOfEnumsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
1065def MonsterStartVectorOfEnumsVector(builder, numElems):
1066    """This method is deprecated. Please switch to Start."""
1067    return StartVectorOfEnumsVector(builder, numElems)
1068def AddSignedEnum(builder, signedEnum): builder.PrependInt8Slot(48, signedEnum, -1)
1069def MonsterAddSignedEnum(builder, signedEnum):
1070    """This method is deprecated. Please switch to AddSignedEnum."""
1071    return AddSignedEnum(builder, signedEnum)
1072def AddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer): builder.PrependUOffsetTRelativeSlot(49, flatbuffers.number_types.UOffsetTFlags.py_type(testrequirednestedflatbuffer), 0)
1073def MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer):
1074    """This method is deprecated. Please switch to AddTestrequirednestedflatbuffer."""
1075    return AddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer)
1076def StartTestrequirednestedflatbufferVector(builder, numElems): return builder.StartVector(1, numElems, 1)
1077def MonsterStartTestrequirednestedflatbufferVector(builder, numElems):
1078    """This method is deprecated. Please switch to Start."""
1079    return StartTestrequirednestedflatbufferVector(builder, numElems)
1080def MakeVectorFromBytes(builder, bytes):
1081    builder.StartVector(1, len(bytes), 1)
1082    builder.head = builder.head - len(bytes)
1083    builder.Bytes[builder.head : builder.head + len(bytes)] = bytes
1084    return builder.EndVector()
1085def MakeTestrequirednestedflatbufferVectorFromBytes(builder, bytes):
1086    builder.StartVector(1, len(bytes), 1)
1087    builder.head = builder.head - len(bytes)
1088    builder.Bytes[builder.head : builder.head + len(bytes)] = bytes
1089    return builder.EndVector()
1090def AddScalarKeySortedTables(builder, scalarKeySortedTables): builder.PrependUOffsetTRelativeSlot(50, flatbuffers.number_types.UOffsetTFlags.py_type(scalarKeySortedTables), 0)
1091def MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables):
1092    """This method is deprecated. Please switch to AddScalarKeySortedTables."""
1093    return AddScalarKeySortedTables(builder, scalarKeySortedTables)
1094def StartScalarKeySortedTablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
1095def MonsterStartScalarKeySortedTablesVector(builder, numElems):
1096    """This method is deprecated. Please switch to Start."""
1097    return StartScalarKeySortedTablesVector(builder, numElems)
1098def End(builder): return builder.EndObject()
1099def MonsterEnd(builder):
1100    """This method is deprecated. Please switch to End."""
1101    return End(builder)
1102import MyGame.Example.Ability
1103import MyGame.Example.Any
1104import MyGame.Example.AnyAmbiguousAliases
1105import MyGame.Example.AnyUniqueAliases
1106import MyGame.Example.Referrable
1107import MyGame.Example.Stat
1108import MyGame.Example.Test
1109import MyGame.Example.TestSimpleTableWithEnum
1110import MyGame.Example.Vec3
1111import MyGame.Example2.Monster
1112import MyGame.InParentNamespace
1113try:
1114    from typing import List, Optional, Union
1115except:
1116    pass
1117
1118class MonsterT(object):
1119
1120    # MonsterT
1121    def __init__(self):
1122        self.pos = None  # type: Optional[MyGame.Example.Vec3.Vec3T]
1123        self.mana = 150  # type: int
1124        self.hp = 100  # type: int
1125        self.name = None  # type: str
1126        self.inventory = None  # type: List[int]
1127        self.color = 8  # type: int
1128        self.testType = 0  # type: int
1129        self.test = None  # type: Union[None, MyGame.Example.Monster.MonsterT, MyGame.Example.TestSimpleTableWithEnum.TestSimpleTableWithEnumT, MyGame.Example2.Monster.MonsterT]
1130        self.test4 = None  # type: List[MyGame.Example.Test.TestT]
1131        self.testarrayofstring = None  # type: List[str]
1132        self.testarrayoftables = None  # type: List[MyGame.Example.Monster.MonsterT]
1133        self.enemy = None  # type: Optional[MyGame.Example.Monster.MonsterT]
1134        self.testnestedflatbuffer = None  # type: List[int]
1135        self.testempty = None  # type: Optional[MyGame.Example.Stat.StatT]
1136        self.testbool = False  # type: bool
1137        self.testhashs32Fnv1 = 0  # type: int
1138        self.testhashu32Fnv1 = 0  # type: int
1139        self.testhashs64Fnv1 = 0  # type: int
1140        self.testhashu64Fnv1 = 0  # type: int
1141        self.testhashs32Fnv1a = 0  # type: int
1142        self.testhashu32Fnv1a = 0  # type: int
1143        self.testhashs64Fnv1a = 0  # type: int
1144        self.testhashu64Fnv1a = 0  # type: int
1145        self.testarrayofbools = None  # type: List[bool]
1146        self.testf = 3.14159  # type: float
1147        self.testf2 = 3.0  # type: float
1148        self.testf3 = 0.0  # type: float
1149        self.testarrayofstring2 = None  # type: List[str]
1150        self.testarrayofsortedstruct = None  # type: List[MyGame.Example.Ability.AbilityT]
1151        self.flex = None  # type: List[int]
1152        self.test5 = None  # type: List[MyGame.Example.Test.TestT]
1153        self.vectorOfLongs = None  # type: List[int]
1154        self.vectorOfDoubles = None  # type: List[float]
1155        self.parentNamespaceTest = None  # type: Optional[MyGame.InParentNamespace.InParentNamespaceT]
1156        self.vectorOfReferrables = None  # type: List[MyGame.Example.Referrable.ReferrableT]
1157        self.singleWeakReference = 0  # type: int
1158        self.vectorOfWeakReferences = None  # type: List[int]
1159        self.vectorOfStrongReferrables = None  # type: List[MyGame.Example.Referrable.ReferrableT]
1160        self.coOwningReference = 0  # type: int
1161        self.vectorOfCoOwningReferences = None  # type: List[int]
1162        self.nonOwningReference = 0  # type: int
1163        self.vectorOfNonOwningReferences = None  # type: List[int]
1164        self.anyUniqueType = 0  # type: int
1165        self.anyUnique = None  # type: Union[None, MyGame.Example.Monster.MonsterT, MyGame.Example.TestSimpleTableWithEnum.TestSimpleTableWithEnumT, MyGame.Example2.Monster.MonsterT]
1166        self.anyAmbiguousType = 0  # type: int
1167        self.anyAmbiguous = None  # type: Union[None, MyGame.Example.Monster.MonsterT, MyGame.Example.Monster.MonsterT, MyGame.Example.Monster.MonsterT]
1168        self.vectorOfEnums = None  # type: List[int]
1169        self.signedEnum = -1  # type: int
1170        self.testrequirednestedflatbuffer = None  # type: List[int]
1171        self.scalarKeySortedTables = None  # type: List[MyGame.Example.Stat.StatT]
1172
1173    @classmethod
1174    def InitFromBuf(cls, buf, pos):
1175        monster = Monster()
1176        monster.Init(buf, pos)
1177        return cls.InitFromObj(monster)
1178
1179    @classmethod
1180    def InitFromObj(cls, monster):
1181        x = MonsterT()
1182        x._UnPack(monster)
1183        return x
1184
1185    # MonsterT
1186    def _UnPack(self, monster):
1187        if monster is None:
1188            return
1189        if monster.Pos() is not None:
1190            self.pos = MyGame.Example.Vec3.Vec3T.InitFromObj(monster.Pos())
1191        self.mana = monster.Mana()
1192        self.hp = monster.Hp()
1193        self.name = monster.Name()
1194        if not monster.InventoryIsNone():
1195            if np is None:
1196                self.inventory = []
1197                for i in range(monster.InventoryLength()):
1198                    self.inventory.append(monster.Inventory(i))
1199            else:
1200                self.inventory = monster.InventoryAsNumpy()
1201        self.color = monster.Color()
1202        self.testType = monster.TestType()
1203        self.test = MyGame.Example.Any.AnyCreator(self.testType, monster.Test())
1204        if not monster.Test4IsNone():
1205            self.test4 = []
1206            for i in range(monster.Test4Length()):
1207                if monster.Test4(i) is None:
1208                    self.test4.append(None)
1209                else:
1210                    test_ = MyGame.Example.Test.TestT.InitFromObj(monster.Test4(i))
1211                    self.test4.append(test_)
1212        if not monster.TestarrayofstringIsNone():
1213            self.testarrayofstring = []
1214            for i in range(monster.TestarrayofstringLength()):
1215                self.testarrayofstring.append(monster.Testarrayofstring(i))
1216        if not monster.TestarrayoftablesIsNone():
1217            self.testarrayoftables = []
1218            for i in range(monster.TestarrayoftablesLength()):
1219                if monster.Testarrayoftables(i) is None:
1220                    self.testarrayoftables.append(None)
1221                else:
1222                    monster_ = MyGame.Example.Monster.MonsterT.InitFromObj(monster.Testarrayoftables(i))
1223                    self.testarrayoftables.append(monster_)
1224        if monster.Enemy() is not None:
1225            self.enemy = MyGame.Example.Monster.MonsterT.InitFromObj(monster.Enemy())
1226        if not monster.TestnestedflatbufferIsNone():
1227            if np is None:
1228                self.testnestedflatbuffer = []
1229                for i in range(monster.TestnestedflatbufferLength()):
1230                    self.testnestedflatbuffer.append(monster.Testnestedflatbuffer(i))
1231            else:
1232                self.testnestedflatbuffer = monster.TestnestedflatbufferAsNumpy()
1233        if monster.Testempty() is not None:
1234            self.testempty = MyGame.Example.Stat.StatT.InitFromObj(monster.Testempty())
1235        self.testbool = monster.Testbool()
1236        self.testhashs32Fnv1 = monster.Testhashs32Fnv1()
1237        self.testhashu32Fnv1 = monster.Testhashu32Fnv1()
1238        self.testhashs64Fnv1 = monster.Testhashs64Fnv1()
1239        self.testhashu64Fnv1 = monster.Testhashu64Fnv1()
1240        self.testhashs32Fnv1a = monster.Testhashs32Fnv1a()
1241        self.testhashu32Fnv1a = monster.Testhashu32Fnv1a()
1242        self.testhashs64Fnv1a = monster.Testhashs64Fnv1a()
1243        self.testhashu64Fnv1a = monster.Testhashu64Fnv1a()
1244        if not monster.TestarrayofboolsIsNone():
1245            if np is None:
1246                self.testarrayofbools = []
1247                for i in range(monster.TestarrayofboolsLength()):
1248                    self.testarrayofbools.append(monster.Testarrayofbools(i))
1249            else:
1250                self.testarrayofbools = monster.TestarrayofboolsAsNumpy()
1251        self.testf = monster.Testf()
1252        self.testf2 = monster.Testf2()
1253        self.testf3 = monster.Testf3()
1254        if not monster.Testarrayofstring2IsNone():
1255            self.testarrayofstring2 = []
1256            for i in range(monster.Testarrayofstring2Length()):
1257                self.testarrayofstring2.append(monster.Testarrayofstring2(i))
1258        if not monster.TestarrayofsortedstructIsNone():
1259            self.testarrayofsortedstruct = []
1260            for i in range(monster.TestarrayofsortedstructLength()):
1261                if monster.Testarrayofsortedstruct(i) is None:
1262                    self.testarrayofsortedstruct.append(None)
1263                else:
1264                    ability_ = MyGame.Example.Ability.AbilityT.InitFromObj(monster.Testarrayofsortedstruct(i))
1265                    self.testarrayofsortedstruct.append(ability_)
1266        if not monster.FlexIsNone():
1267            if np is None:
1268                self.flex = []
1269                for i in range(monster.FlexLength()):
1270                    self.flex.append(monster.Flex(i))
1271            else:
1272                self.flex = monster.FlexAsNumpy()
1273        if not monster.Test5IsNone():
1274            self.test5 = []
1275            for i in range(monster.Test5Length()):
1276                if monster.Test5(i) is None:
1277                    self.test5.append(None)
1278                else:
1279                    test_ = MyGame.Example.Test.TestT.InitFromObj(monster.Test5(i))
1280                    self.test5.append(test_)
1281        if not monster.VectorOfLongsIsNone():
1282            if np is None:
1283                self.vectorOfLongs = []
1284                for i in range(monster.VectorOfLongsLength()):
1285                    self.vectorOfLongs.append(monster.VectorOfLongs(i))
1286            else:
1287                self.vectorOfLongs = monster.VectorOfLongsAsNumpy()
1288        if not monster.VectorOfDoublesIsNone():
1289            if np is None:
1290                self.vectorOfDoubles = []
1291                for i in range(monster.VectorOfDoublesLength()):
1292                    self.vectorOfDoubles.append(monster.VectorOfDoubles(i))
1293            else:
1294                self.vectorOfDoubles = monster.VectorOfDoublesAsNumpy()
1295        if monster.ParentNamespaceTest() is not None:
1296            self.parentNamespaceTest = MyGame.InParentNamespace.InParentNamespaceT.InitFromObj(monster.ParentNamespaceTest())
1297        if not monster.VectorOfReferrablesIsNone():
1298            self.vectorOfReferrables = []
1299            for i in range(monster.VectorOfReferrablesLength()):
1300                if monster.VectorOfReferrables(i) is None:
1301                    self.vectorOfReferrables.append(None)
1302                else:
1303                    referrable_ = MyGame.Example.Referrable.ReferrableT.InitFromObj(monster.VectorOfReferrables(i))
1304                    self.vectorOfReferrables.append(referrable_)
1305        self.singleWeakReference = monster.SingleWeakReference()
1306        if not monster.VectorOfWeakReferencesIsNone():
1307            if np is None:
1308                self.vectorOfWeakReferences = []
1309                for i in range(monster.VectorOfWeakReferencesLength()):
1310                    self.vectorOfWeakReferences.append(monster.VectorOfWeakReferences(i))
1311            else:
1312                self.vectorOfWeakReferences = monster.VectorOfWeakReferencesAsNumpy()
1313        if not monster.VectorOfStrongReferrablesIsNone():
1314            self.vectorOfStrongReferrables = []
1315            for i in range(monster.VectorOfStrongReferrablesLength()):
1316                if monster.VectorOfStrongReferrables(i) is None:
1317                    self.vectorOfStrongReferrables.append(None)
1318                else:
1319                    referrable_ = MyGame.Example.Referrable.ReferrableT.InitFromObj(monster.VectorOfStrongReferrables(i))
1320                    self.vectorOfStrongReferrables.append(referrable_)
1321        self.coOwningReference = monster.CoOwningReference()
1322        if not monster.VectorOfCoOwningReferencesIsNone():
1323            if np is None:
1324                self.vectorOfCoOwningReferences = []
1325                for i in range(monster.VectorOfCoOwningReferencesLength()):
1326                    self.vectorOfCoOwningReferences.append(monster.VectorOfCoOwningReferences(i))
1327            else:
1328                self.vectorOfCoOwningReferences = monster.VectorOfCoOwningReferencesAsNumpy()
1329        self.nonOwningReference = monster.NonOwningReference()
1330        if not monster.VectorOfNonOwningReferencesIsNone():
1331            if np is None:
1332                self.vectorOfNonOwningReferences = []
1333                for i in range(monster.VectorOfNonOwningReferencesLength()):
1334                    self.vectorOfNonOwningReferences.append(monster.VectorOfNonOwningReferences(i))
1335            else:
1336                self.vectorOfNonOwningReferences = monster.VectorOfNonOwningReferencesAsNumpy()
1337        self.anyUniqueType = monster.AnyUniqueType()
1338        self.anyUnique = MyGame.Example.AnyUniqueAliases.AnyUniqueAliasesCreator(self.anyUniqueType, monster.AnyUnique())
1339        self.anyAmbiguousType = monster.AnyAmbiguousType()
1340        self.anyAmbiguous = MyGame.Example.AnyAmbiguousAliases.AnyAmbiguousAliasesCreator(self.anyAmbiguousType, monster.AnyAmbiguous())
1341        if not monster.VectorOfEnumsIsNone():
1342            if np is None:
1343                self.vectorOfEnums = []
1344                for i in range(monster.VectorOfEnumsLength()):
1345                    self.vectorOfEnums.append(monster.VectorOfEnums(i))
1346            else:
1347                self.vectorOfEnums = monster.VectorOfEnumsAsNumpy()
1348        self.signedEnum = monster.SignedEnum()
1349        if not monster.TestrequirednestedflatbufferIsNone():
1350            if np is None:
1351                self.testrequirednestedflatbuffer = []
1352                for i in range(monster.TestrequirednestedflatbufferLength()):
1353                    self.testrequirednestedflatbuffer.append(monster.Testrequirednestedflatbuffer(i))
1354            else:
1355                self.testrequirednestedflatbuffer = monster.TestrequirednestedflatbufferAsNumpy()
1356        if not monster.ScalarKeySortedTablesIsNone():
1357            self.scalarKeySortedTables = []
1358            for i in range(monster.ScalarKeySortedTablesLength()):
1359                if monster.ScalarKeySortedTables(i) is None:
1360                    self.scalarKeySortedTables.append(None)
1361                else:
1362                    stat_ = MyGame.Example.Stat.StatT.InitFromObj(monster.ScalarKeySortedTables(i))
1363                    self.scalarKeySortedTables.append(stat_)
1364
1365    # MonsterT
1366    def Pack(self, builder):
1367        if self.name is not None:
1368            name = builder.CreateString(self.name)
1369        if self.inventory is not None:
1370            if np is not None and type(self.inventory) is np.ndarray:
1371                inventory = builder.CreateNumpyVector(self.inventory)
1372            else:
1373                StartInventoryVector(builder, len(self.inventory))
1374                for i in reversed(range(len(self.inventory))):
1375                    builder.PrependUint8(self.inventory[i])
1376                inventory = builder.EndVector()
1377        if self.test is not None:
1378            test = self.test.Pack(builder)
1379        if self.test4 is not None:
1380            StartTest4Vector(builder, len(self.test4))
1381            for i in reversed(range(len(self.test4))):
1382                self.test4[i].Pack(builder)
1383            test4 = builder.EndVector()
1384        if self.testarrayofstring is not None:
1385            testarrayofstringlist = []
1386            for i in range(len(self.testarrayofstring)):
1387                testarrayofstringlist.append(builder.CreateString(self.testarrayofstring[i]))
1388            StartTestarrayofstringVector(builder, len(self.testarrayofstring))
1389            for i in reversed(range(len(self.testarrayofstring))):
1390                builder.PrependUOffsetTRelative(testarrayofstringlist[i])
1391            testarrayofstring = builder.EndVector()
1392        if self.testarrayoftables is not None:
1393            testarrayoftableslist = []
1394            for i in range(len(self.testarrayoftables)):
1395                testarrayoftableslist.append(self.testarrayoftables[i].Pack(builder))
1396            StartTestarrayoftablesVector(builder, len(self.testarrayoftables))
1397            for i in reversed(range(len(self.testarrayoftables))):
1398                builder.PrependUOffsetTRelative(testarrayoftableslist[i])
1399            testarrayoftables = builder.EndVector()
1400        if self.enemy is not None:
1401            enemy = self.enemy.Pack(builder)
1402        if self.testnestedflatbuffer is not None:
1403            if np is not None and type(self.testnestedflatbuffer) is np.ndarray:
1404                testnestedflatbuffer = builder.CreateNumpyVector(self.testnestedflatbuffer)
1405            else:
1406                StartTestnestedflatbufferVector(builder, len(self.testnestedflatbuffer))
1407                for i in reversed(range(len(self.testnestedflatbuffer))):
1408                    builder.PrependUint8(self.testnestedflatbuffer[i])
1409                testnestedflatbuffer = builder.EndVector()
1410        if self.testempty is not None:
1411            testempty = self.testempty.Pack(builder)
1412        if self.testarrayofbools is not None:
1413            if np is not None and type(self.testarrayofbools) is np.ndarray:
1414                testarrayofbools = builder.CreateNumpyVector(self.testarrayofbools)
1415            else:
1416                StartTestarrayofboolsVector(builder, len(self.testarrayofbools))
1417                for i in reversed(range(len(self.testarrayofbools))):
1418                    builder.PrependBool(self.testarrayofbools[i])
1419                testarrayofbools = builder.EndVector()
1420        if self.testarrayofstring2 is not None:
1421            testarrayofstring2list = []
1422            for i in range(len(self.testarrayofstring2)):
1423                testarrayofstring2list.append(builder.CreateString(self.testarrayofstring2[i]))
1424            StartTestarrayofstring2Vector(builder, len(self.testarrayofstring2))
1425            for i in reversed(range(len(self.testarrayofstring2))):
1426                builder.PrependUOffsetTRelative(testarrayofstring2list[i])
1427            testarrayofstring2 = builder.EndVector()
1428        if self.testarrayofsortedstruct is not None:
1429            StartTestarrayofsortedstructVector(builder, len(self.testarrayofsortedstruct))
1430            for i in reversed(range(len(self.testarrayofsortedstruct))):
1431                self.testarrayofsortedstruct[i].Pack(builder)
1432            testarrayofsortedstruct = builder.EndVector()
1433        if self.flex is not None:
1434            if np is not None and type(self.flex) is np.ndarray:
1435                flex = builder.CreateNumpyVector(self.flex)
1436            else:
1437                StartFlexVector(builder, len(self.flex))
1438                for i in reversed(range(len(self.flex))):
1439                    builder.PrependUint8(self.flex[i])
1440                flex = builder.EndVector()
1441        if self.test5 is not None:
1442            StartTest5Vector(builder, len(self.test5))
1443            for i in reversed(range(len(self.test5))):
1444                self.test5[i].Pack(builder)
1445            test5 = builder.EndVector()
1446        if self.vectorOfLongs is not None:
1447            if np is not None and type(self.vectorOfLongs) is np.ndarray:
1448                vectorOfLongs = builder.CreateNumpyVector(self.vectorOfLongs)
1449            else:
1450                StartVectorOfLongsVector(builder, len(self.vectorOfLongs))
1451                for i in reversed(range(len(self.vectorOfLongs))):
1452                    builder.PrependInt64(self.vectorOfLongs[i])
1453                vectorOfLongs = builder.EndVector()
1454        if self.vectorOfDoubles is not None:
1455            if np is not None and type(self.vectorOfDoubles) is np.ndarray:
1456                vectorOfDoubles = builder.CreateNumpyVector(self.vectorOfDoubles)
1457            else:
1458                StartVectorOfDoublesVector(builder, len(self.vectorOfDoubles))
1459                for i in reversed(range(len(self.vectorOfDoubles))):
1460                    builder.PrependFloat64(self.vectorOfDoubles[i])
1461                vectorOfDoubles = builder.EndVector()
1462        if self.parentNamespaceTest is not None:
1463            parentNamespaceTest = self.parentNamespaceTest.Pack(builder)
1464        if self.vectorOfReferrables is not None:
1465            vectorOfReferrableslist = []
1466            for i in range(len(self.vectorOfReferrables)):
1467                vectorOfReferrableslist.append(self.vectorOfReferrables[i].Pack(builder))
1468            StartVectorOfReferrablesVector(builder, len(self.vectorOfReferrables))
1469            for i in reversed(range(len(self.vectorOfReferrables))):
1470                builder.PrependUOffsetTRelative(vectorOfReferrableslist[i])
1471            vectorOfReferrables = builder.EndVector()
1472        if self.vectorOfWeakReferences is not None:
1473            if np is not None and type(self.vectorOfWeakReferences) is np.ndarray:
1474                vectorOfWeakReferences = builder.CreateNumpyVector(self.vectorOfWeakReferences)
1475            else:
1476                StartVectorOfWeakReferencesVector(builder, len(self.vectorOfWeakReferences))
1477                for i in reversed(range(len(self.vectorOfWeakReferences))):
1478                    builder.PrependUint64(self.vectorOfWeakReferences[i])
1479                vectorOfWeakReferences = builder.EndVector()
1480        if self.vectorOfStrongReferrables is not None:
1481            vectorOfStrongReferrableslist = []
1482            for i in range(len(self.vectorOfStrongReferrables)):
1483                vectorOfStrongReferrableslist.append(self.vectorOfStrongReferrables[i].Pack(builder))
1484            StartVectorOfStrongReferrablesVector(builder, len(self.vectorOfStrongReferrables))
1485            for i in reversed(range(len(self.vectorOfStrongReferrables))):
1486                builder.PrependUOffsetTRelative(vectorOfStrongReferrableslist[i])
1487            vectorOfStrongReferrables = builder.EndVector()
1488        if self.vectorOfCoOwningReferences is not None:
1489            if np is not None and type(self.vectorOfCoOwningReferences) is np.ndarray:
1490                vectorOfCoOwningReferences = builder.CreateNumpyVector(self.vectorOfCoOwningReferences)
1491            else:
1492                StartVectorOfCoOwningReferencesVector(builder, len(self.vectorOfCoOwningReferences))
1493                for i in reversed(range(len(self.vectorOfCoOwningReferences))):
1494                    builder.PrependUint64(self.vectorOfCoOwningReferences[i])
1495                vectorOfCoOwningReferences = builder.EndVector()
1496        if self.vectorOfNonOwningReferences is not None:
1497            if np is not None and type(self.vectorOfNonOwningReferences) is np.ndarray:
1498                vectorOfNonOwningReferences = builder.CreateNumpyVector(self.vectorOfNonOwningReferences)
1499            else:
1500                StartVectorOfNonOwningReferencesVector(builder, len(self.vectorOfNonOwningReferences))
1501                for i in reversed(range(len(self.vectorOfNonOwningReferences))):
1502                    builder.PrependUint64(self.vectorOfNonOwningReferences[i])
1503                vectorOfNonOwningReferences = builder.EndVector()
1504        if self.anyUnique is not None:
1505            anyUnique = self.anyUnique.Pack(builder)
1506        if self.anyAmbiguous is not None:
1507            anyAmbiguous = self.anyAmbiguous.Pack(builder)
1508        if self.vectorOfEnums is not None:
1509            if np is not None and type(self.vectorOfEnums) is np.ndarray:
1510                vectorOfEnums = builder.CreateNumpyVector(self.vectorOfEnums)
1511            else:
1512                StartVectorOfEnumsVector(builder, len(self.vectorOfEnums))
1513                for i in reversed(range(len(self.vectorOfEnums))):
1514                    builder.PrependUint8(self.vectorOfEnums[i])
1515                vectorOfEnums = builder.EndVector()
1516        if self.testrequirednestedflatbuffer is not None:
1517            if np is not None and type(self.testrequirednestedflatbuffer) is np.ndarray:
1518                testrequirednestedflatbuffer = builder.CreateNumpyVector(self.testrequirednestedflatbuffer)
1519            else:
1520                StartTestrequirednestedflatbufferVector(builder, len(self.testrequirednestedflatbuffer))
1521                for i in reversed(range(len(self.testrequirednestedflatbuffer))):
1522                    builder.PrependUint8(self.testrequirednestedflatbuffer[i])
1523                testrequirednestedflatbuffer = builder.EndVector()
1524        if self.scalarKeySortedTables is not None:
1525            scalarKeySortedTableslist = []
1526            for i in range(len(self.scalarKeySortedTables)):
1527                scalarKeySortedTableslist.append(self.scalarKeySortedTables[i].Pack(builder))
1528            StartScalarKeySortedTablesVector(builder, len(self.scalarKeySortedTables))
1529            for i in reversed(range(len(self.scalarKeySortedTables))):
1530                builder.PrependUOffsetTRelative(scalarKeySortedTableslist[i])
1531            scalarKeySortedTables = builder.EndVector()
1532        Start(builder)
1533        if self.pos is not None:
1534            pos = self.pos.Pack(builder)
1535            AddPos(builder, pos)
1536        AddMana(builder, self.mana)
1537        AddHp(builder, self.hp)
1538        if self.name is not None:
1539            AddName(builder, name)
1540        if self.inventory is not None:
1541            AddInventory(builder, inventory)
1542        AddColor(builder, self.color)
1543        AddTestType(builder, self.testType)
1544        if self.test is not None:
1545            AddTest(builder, test)
1546        if self.test4 is not None:
1547            AddTest4(builder, test4)
1548        if self.testarrayofstring is not None:
1549            AddTestarrayofstring(builder, testarrayofstring)
1550        if self.testarrayoftables is not None:
1551            AddTestarrayoftables(builder, testarrayoftables)
1552        if self.enemy is not None:
1553            AddEnemy(builder, enemy)
1554        if self.testnestedflatbuffer is not None:
1555            AddTestnestedflatbuffer(builder, testnestedflatbuffer)
1556        if self.testempty is not None:
1557            AddTestempty(builder, testempty)
1558        AddTestbool(builder, self.testbool)
1559        AddTesthashs32Fnv1(builder, self.testhashs32Fnv1)
1560        AddTesthashu32Fnv1(builder, self.testhashu32Fnv1)
1561        AddTesthashs64Fnv1(builder, self.testhashs64Fnv1)
1562        AddTesthashu64Fnv1(builder, self.testhashu64Fnv1)
1563        AddTesthashs32Fnv1a(builder, self.testhashs32Fnv1a)
1564        AddTesthashu32Fnv1a(builder, self.testhashu32Fnv1a)
1565        AddTesthashs64Fnv1a(builder, self.testhashs64Fnv1a)
1566        AddTesthashu64Fnv1a(builder, self.testhashu64Fnv1a)
1567        if self.testarrayofbools is not None:
1568            AddTestarrayofbools(builder, testarrayofbools)
1569        AddTestf(builder, self.testf)
1570        AddTestf2(builder, self.testf2)
1571        AddTestf3(builder, self.testf3)
1572        if self.testarrayofstring2 is not None:
1573            AddTestarrayofstring2(builder, testarrayofstring2)
1574        if self.testarrayofsortedstruct is not None:
1575            AddTestarrayofsortedstruct(builder, testarrayofsortedstruct)
1576        if self.flex is not None:
1577            AddFlex(builder, flex)
1578        if self.test5 is not None:
1579            AddTest5(builder, test5)
1580        if self.vectorOfLongs is not None:
1581            AddVectorOfLongs(builder, vectorOfLongs)
1582        if self.vectorOfDoubles is not None:
1583            AddVectorOfDoubles(builder, vectorOfDoubles)
1584        if self.parentNamespaceTest is not None:
1585            AddParentNamespaceTest(builder, parentNamespaceTest)
1586        if self.vectorOfReferrables is not None:
1587            AddVectorOfReferrables(builder, vectorOfReferrables)
1588        AddSingleWeakReference(builder, self.singleWeakReference)
1589        if self.vectorOfWeakReferences is not None:
1590            AddVectorOfWeakReferences(builder, vectorOfWeakReferences)
1591        if self.vectorOfStrongReferrables is not None:
1592            AddVectorOfStrongReferrables(builder, vectorOfStrongReferrables)
1593        AddCoOwningReference(builder, self.coOwningReference)
1594        if self.vectorOfCoOwningReferences is not None:
1595            AddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences)
1596        AddNonOwningReference(builder, self.nonOwningReference)
1597        if self.vectorOfNonOwningReferences is not None:
1598            AddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences)
1599        AddAnyUniqueType(builder, self.anyUniqueType)
1600        if self.anyUnique is not None:
1601            AddAnyUnique(builder, anyUnique)
1602        AddAnyAmbiguousType(builder, self.anyAmbiguousType)
1603        if self.anyAmbiguous is not None:
1604            AddAnyAmbiguous(builder, anyAmbiguous)
1605        if self.vectorOfEnums is not None:
1606            AddVectorOfEnums(builder, vectorOfEnums)
1607        AddSignedEnum(builder, self.signedEnum)
1608        if self.testrequirednestedflatbuffer is not None:
1609            AddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer)
1610        if self.scalarKeySortedTables is not None:
1611            AddScalarKeySortedTables(builder, scalarKeySortedTables)
1612        monster = End(builder)
1613        return monster
1614