• 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 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
794    # Monster
795    def NativeInline(self):
796        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(106))
797        if o != 0:
798            x = o + self._tab.Pos
799            from MyGame.Example.Test import Test
800            obj = Test()
801            obj.Init(self._tab.Bytes, x)
802            return obj
803        return None
804
805    # Monster
806    def LongEnumNonEnumDefault(self):
807        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(108))
808        if o != 0:
809            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
810        return 0
811
812    # Monster
813    def LongEnumNormalDefault(self):
814        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(110))
815        if o != 0:
816            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
817        return 2
818
819    # Monster
820    def NanDefault(self):
821        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(112))
822        if o != 0:
823            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
824        return float('nan')
825
826    # Monster
827    def InfDefault(self):
828        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(114))
829        if o != 0:
830            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
831        return float('inf')
832
833    # Monster
834    def PositiveInfDefault(self):
835        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(116))
836        if o != 0:
837            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
838        return float('inf')
839
840    # Monster
841    def InfinityDefault(self):
842        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(118))
843        if o != 0:
844            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
845        return float('inf')
846
847    # Monster
848    def PositiveInfinityDefault(self):
849        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(120))
850        if o != 0:
851            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
852        return float('inf')
853
854    # Monster
855    def NegativeInfDefault(self):
856        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(122))
857        if o != 0:
858            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
859        return float('-inf')
860
861    # Monster
862    def NegativeInfinityDefault(self):
863        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(124))
864        if o != 0:
865            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
866        return float('-inf')
867
868    # Monster
869    def DoubleInfDefault(self):
870        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(126))
871        if o != 0:
872            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
873        return float('inf')
874
875def MonsterStart(builder):
876    builder.StartObject(62)
877
878def Start(builder):
879    MonsterStart(builder)
880
881def MonsterAddPos(builder, pos):
882    builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pos), 0)
883
884def AddPos(builder, pos):
885    MonsterAddPos(builder, pos)
886
887def MonsterAddMana(builder, mana):
888    builder.PrependInt16Slot(1, mana, 150)
889
890def AddMana(builder, mana):
891    MonsterAddMana(builder, mana)
892
893def MonsterAddHp(builder, hp):
894    builder.PrependInt16Slot(2, hp, 100)
895
896def AddHp(builder, hp):
897    MonsterAddHp(builder, hp)
898
899def MonsterAddName(builder, name):
900    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
901
902def AddName(builder, name):
903    MonsterAddName(builder, name)
904
905def MonsterAddInventory(builder, inventory):
906    builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(inventory), 0)
907
908def AddInventory(builder, inventory):
909    MonsterAddInventory(builder, inventory)
910
911def MonsterStartInventoryVector(builder, numElems):
912    return builder.StartVector(1, numElems, 1)
913
914def StartInventoryVector(builder, numElems):
915    return MonsterStartInventoryVector(builder, numElems)
916
917def MonsterAddColor(builder, color):
918    builder.PrependUint8Slot(6, color, 8)
919
920def AddColor(builder, color):
921    MonsterAddColor(builder, color)
922
923def MonsterAddTestType(builder, testType):
924    builder.PrependUint8Slot(7, testType, 0)
925
926def AddTestType(builder, testType):
927    MonsterAddTestType(builder, testType)
928
929def MonsterAddTest(builder, test):
930    builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(test), 0)
931
932def AddTest(builder, test):
933    MonsterAddTest(builder, test)
934
935def MonsterAddTest4(builder, test4):
936    builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(test4), 0)
937
938def AddTest4(builder, test4):
939    MonsterAddTest4(builder, test4)
940
941def MonsterStartTest4Vector(builder, numElems):
942    return builder.StartVector(4, numElems, 2)
943
944def StartTest4Vector(builder, numElems):
945    return MonsterStartTest4Vector(builder, numElems)
946
947def MonsterAddTestarrayofstring(builder, testarrayofstring):
948    builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring), 0)
949
950def AddTestarrayofstring(builder, testarrayofstring):
951    MonsterAddTestarrayofstring(builder, testarrayofstring)
952
953def MonsterStartTestarrayofstringVector(builder, numElems):
954    return builder.StartVector(4, numElems, 4)
955
956def StartTestarrayofstringVector(builder, numElems):
957    return MonsterStartTestarrayofstringVector(builder, numElems)
958
959def MonsterAddTestarrayoftables(builder, testarrayoftables):
960    builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayoftables), 0)
961
962def AddTestarrayoftables(builder, testarrayoftables):
963    MonsterAddTestarrayoftables(builder, testarrayoftables)
964
965def MonsterStartTestarrayoftablesVector(builder, numElems):
966    return builder.StartVector(4, numElems, 4)
967
968def StartTestarrayoftablesVector(builder, numElems):
969    return MonsterStartTestarrayoftablesVector(builder, numElems)
970
971def MonsterAddEnemy(builder, enemy):
972    builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(enemy), 0)
973
974def AddEnemy(builder, enemy):
975    MonsterAddEnemy(builder, enemy)
976
977def MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer):
978    builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(testnestedflatbuffer), 0)
979
980def AddTestnestedflatbuffer(builder, testnestedflatbuffer):
981    MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer)
982
983def MonsterStartTestnestedflatbufferVector(builder, numElems):
984    return builder.StartVector(1, numElems, 1)
985
986def StartTestnestedflatbufferVector(builder, numElems):
987    return MonsterStartTestnestedflatbufferVector(builder, numElems)
988
989def MonsterMakeTestnestedflatbufferVectorFromBytes(builder, bytes):
990    builder.StartVector(1, len(bytes), 1)
991    builder.head = builder.head - len(bytes)
992    builder.Bytes[builder.head : builder.head + len(bytes)] = bytes
993    return builder.EndVector()
994def MakeTestnestedflatbufferVectorFromBytes(builder, bytes):
995    return MonsterMakeTestnestedflatbufferVectorFromBytes(builder, bytes)
996def MonsterAddTestempty(builder, testempty):
997    builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(testempty), 0)
998
999def AddTestempty(builder, testempty):
1000    MonsterAddTestempty(builder, testempty)
1001
1002def MonsterAddTestbool(builder, testbool):
1003    builder.PrependBoolSlot(15, testbool, 0)
1004
1005def AddTestbool(builder, testbool):
1006    MonsterAddTestbool(builder, testbool)
1007
1008def MonsterAddTesthashs32Fnv1(builder, testhashs32Fnv1):
1009    builder.PrependInt32Slot(16, testhashs32Fnv1, 0)
1010
1011def AddTesthashs32Fnv1(builder, testhashs32Fnv1):
1012    MonsterAddTesthashs32Fnv1(builder, testhashs32Fnv1)
1013
1014def MonsterAddTesthashu32Fnv1(builder, testhashu32Fnv1):
1015    builder.PrependUint32Slot(17, testhashu32Fnv1, 0)
1016
1017def AddTesthashu32Fnv1(builder, testhashu32Fnv1):
1018    MonsterAddTesthashu32Fnv1(builder, testhashu32Fnv1)
1019
1020def MonsterAddTesthashs64Fnv1(builder, testhashs64Fnv1):
1021    builder.PrependInt64Slot(18, testhashs64Fnv1, 0)
1022
1023def AddTesthashs64Fnv1(builder, testhashs64Fnv1):
1024    MonsterAddTesthashs64Fnv1(builder, testhashs64Fnv1)
1025
1026def MonsterAddTesthashu64Fnv1(builder, testhashu64Fnv1):
1027    builder.PrependUint64Slot(19, testhashu64Fnv1, 0)
1028
1029def AddTesthashu64Fnv1(builder, testhashu64Fnv1):
1030    MonsterAddTesthashu64Fnv1(builder, testhashu64Fnv1)
1031
1032def MonsterAddTesthashs32Fnv1a(builder, testhashs32Fnv1a):
1033    builder.PrependInt32Slot(20, testhashs32Fnv1a, 0)
1034
1035def AddTesthashs32Fnv1a(builder, testhashs32Fnv1a):
1036    MonsterAddTesthashs32Fnv1a(builder, testhashs32Fnv1a)
1037
1038def MonsterAddTesthashu32Fnv1a(builder, testhashu32Fnv1a):
1039    builder.PrependUint32Slot(21, testhashu32Fnv1a, 0)
1040
1041def AddTesthashu32Fnv1a(builder, testhashu32Fnv1a):
1042    MonsterAddTesthashu32Fnv1a(builder, testhashu32Fnv1a)
1043
1044def MonsterAddTesthashs64Fnv1a(builder, testhashs64Fnv1a):
1045    builder.PrependInt64Slot(22, testhashs64Fnv1a, 0)
1046
1047def AddTesthashs64Fnv1a(builder, testhashs64Fnv1a):
1048    MonsterAddTesthashs64Fnv1a(builder, testhashs64Fnv1a)
1049
1050def MonsterAddTesthashu64Fnv1a(builder, testhashu64Fnv1a):
1051    builder.PrependUint64Slot(23, testhashu64Fnv1a, 0)
1052
1053def AddTesthashu64Fnv1a(builder, testhashu64Fnv1a):
1054    MonsterAddTesthashu64Fnv1a(builder, testhashu64Fnv1a)
1055
1056def MonsterAddTestarrayofbools(builder, testarrayofbools):
1057    builder.PrependUOffsetTRelativeSlot(24, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofbools), 0)
1058
1059def AddTestarrayofbools(builder, testarrayofbools):
1060    MonsterAddTestarrayofbools(builder, testarrayofbools)
1061
1062def MonsterStartTestarrayofboolsVector(builder, numElems):
1063    return builder.StartVector(1, numElems, 1)
1064
1065def StartTestarrayofboolsVector(builder, numElems):
1066    return MonsterStartTestarrayofboolsVector(builder, numElems)
1067
1068def MonsterAddTestf(builder, testf):
1069    builder.PrependFloat32Slot(25, testf, 3.14159)
1070
1071def AddTestf(builder, testf):
1072    MonsterAddTestf(builder, testf)
1073
1074def MonsterAddTestf2(builder, testf2):
1075    builder.PrependFloat32Slot(26, testf2, 3.0)
1076
1077def AddTestf2(builder, testf2):
1078    MonsterAddTestf2(builder, testf2)
1079
1080def MonsterAddTestf3(builder, testf3):
1081    builder.PrependFloat32Slot(27, testf3, 0.0)
1082
1083def AddTestf3(builder, testf3):
1084    MonsterAddTestf3(builder, testf3)
1085
1086def MonsterAddTestarrayofstring2(builder, testarrayofstring2):
1087    builder.PrependUOffsetTRelativeSlot(28, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring2), 0)
1088
1089def AddTestarrayofstring2(builder, testarrayofstring2):
1090    MonsterAddTestarrayofstring2(builder, testarrayofstring2)
1091
1092def MonsterStartTestarrayofstring2Vector(builder, numElems):
1093    return builder.StartVector(4, numElems, 4)
1094
1095def StartTestarrayofstring2Vector(builder, numElems):
1096    return MonsterStartTestarrayofstring2Vector(builder, numElems)
1097
1098def MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct):
1099    builder.PrependUOffsetTRelativeSlot(29, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofsortedstruct), 0)
1100
1101def AddTestarrayofsortedstruct(builder, testarrayofsortedstruct):
1102    MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct)
1103
1104def MonsterStartTestarrayofsortedstructVector(builder, numElems):
1105    return builder.StartVector(8, numElems, 4)
1106
1107def StartTestarrayofsortedstructVector(builder, numElems):
1108    return MonsterStartTestarrayofsortedstructVector(builder, numElems)
1109
1110def MonsterAddFlex(builder, flex):
1111    builder.PrependUOffsetTRelativeSlot(30, flatbuffers.number_types.UOffsetTFlags.py_type(flex), 0)
1112
1113def AddFlex(builder, flex):
1114    MonsterAddFlex(builder, flex)
1115
1116def MonsterStartFlexVector(builder, numElems):
1117    return builder.StartVector(1, numElems, 1)
1118
1119def StartFlexVector(builder, numElems):
1120    return MonsterStartFlexVector(builder, numElems)
1121
1122def MonsterAddTest5(builder, test5):
1123    builder.PrependUOffsetTRelativeSlot(31, flatbuffers.number_types.UOffsetTFlags.py_type(test5), 0)
1124
1125def AddTest5(builder, test5):
1126    MonsterAddTest5(builder, test5)
1127
1128def MonsterStartTest5Vector(builder, numElems):
1129    return builder.StartVector(4, numElems, 2)
1130
1131def StartTest5Vector(builder, numElems):
1132    return MonsterStartTest5Vector(builder, numElems)
1133
1134def MonsterAddVectorOfLongs(builder, vectorOfLongs):
1135    builder.PrependUOffsetTRelativeSlot(32, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfLongs), 0)
1136
1137def AddVectorOfLongs(builder, vectorOfLongs):
1138    MonsterAddVectorOfLongs(builder, vectorOfLongs)
1139
1140def MonsterStartVectorOfLongsVector(builder, numElems):
1141    return builder.StartVector(8, numElems, 8)
1142
1143def StartVectorOfLongsVector(builder, numElems):
1144    return MonsterStartVectorOfLongsVector(builder, numElems)
1145
1146def MonsterAddVectorOfDoubles(builder, vectorOfDoubles):
1147    builder.PrependUOffsetTRelativeSlot(33, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfDoubles), 0)
1148
1149def AddVectorOfDoubles(builder, vectorOfDoubles):
1150    MonsterAddVectorOfDoubles(builder, vectorOfDoubles)
1151
1152def MonsterStartVectorOfDoublesVector(builder, numElems):
1153    return builder.StartVector(8, numElems, 8)
1154
1155def StartVectorOfDoublesVector(builder, numElems):
1156    return MonsterStartVectorOfDoublesVector(builder, numElems)
1157
1158def MonsterAddParentNamespaceTest(builder, parentNamespaceTest):
1159    builder.PrependUOffsetTRelativeSlot(34, flatbuffers.number_types.UOffsetTFlags.py_type(parentNamespaceTest), 0)
1160
1161def AddParentNamespaceTest(builder, parentNamespaceTest):
1162    MonsterAddParentNamespaceTest(builder, parentNamespaceTest)
1163
1164def MonsterAddVectorOfReferrables(builder, vectorOfReferrables):
1165    builder.PrependUOffsetTRelativeSlot(35, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfReferrables), 0)
1166
1167def AddVectorOfReferrables(builder, vectorOfReferrables):
1168    MonsterAddVectorOfReferrables(builder, vectorOfReferrables)
1169
1170def MonsterStartVectorOfReferrablesVector(builder, numElems):
1171    return builder.StartVector(4, numElems, 4)
1172
1173def StartVectorOfReferrablesVector(builder, numElems):
1174    return MonsterStartVectorOfReferrablesVector(builder, numElems)
1175
1176def MonsterAddSingleWeakReference(builder, singleWeakReference):
1177    builder.PrependUint64Slot(36, singleWeakReference, 0)
1178
1179def AddSingleWeakReference(builder, singleWeakReference):
1180    MonsterAddSingleWeakReference(builder, singleWeakReference)
1181
1182def MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences):
1183    builder.PrependUOffsetTRelativeSlot(37, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfWeakReferences), 0)
1184
1185def AddVectorOfWeakReferences(builder, vectorOfWeakReferences):
1186    MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences)
1187
1188def MonsterStartVectorOfWeakReferencesVector(builder, numElems):
1189    return builder.StartVector(8, numElems, 8)
1190
1191def StartVectorOfWeakReferencesVector(builder, numElems):
1192    return MonsterStartVectorOfWeakReferencesVector(builder, numElems)
1193
1194def MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables):
1195    builder.PrependUOffsetTRelativeSlot(38, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfStrongReferrables), 0)
1196
1197def AddVectorOfStrongReferrables(builder, vectorOfStrongReferrables):
1198    MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables)
1199
1200def MonsterStartVectorOfStrongReferrablesVector(builder, numElems):
1201    return builder.StartVector(4, numElems, 4)
1202
1203def StartVectorOfStrongReferrablesVector(builder, numElems):
1204    return MonsterStartVectorOfStrongReferrablesVector(builder, numElems)
1205
1206def MonsterAddCoOwningReference(builder, coOwningReference):
1207    builder.PrependUint64Slot(39, coOwningReference, 0)
1208
1209def AddCoOwningReference(builder, coOwningReference):
1210    MonsterAddCoOwningReference(builder, coOwningReference)
1211
1212def MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences):
1213    builder.PrependUOffsetTRelativeSlot(40, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfCoOwningReferences), 0)
1214
1215def AddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences):
1216    MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences)
1217
1218def MonsterStartVectorOfCoOwningReferencesVector(builder, numElems):
1219    return builder.StartVector(8, numElems, 8)
1220
1221def StartVectorOfCoOwningReferencesVector(builder, numElems):
1222    return MonsterStartVectorOfCoOwningReferencesVector(builder, numElems)
1223
1224def MonsterAddNonOwningReference(builder, nonOwningReference):
1225    builder.PrependUint64Slot(41, nonOwningReference, 0)
1226
1227def AddNonOwningReference(builder, nonOwningReference):
1228    MonsterAddNonOwningReference(builder, nonOwningReference)
1229
1230def MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences):
1231    builder.PrependUOffsetTRelativeSlot(42, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfNonOwningReferences), 0)
1232
1233def AddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences):
1234    MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences)
1235
1236def MonsterStartVectorOfNonOwningReferencesVector(builder, numElems):
1237    return builder.StartVector(8, numElems, 8)
1238
1239def StartVectorOfNonOwningReferencesVector(builder, numElems):
1240    return MonsterStartVectorOfNonOwningReferencesVector(builder, numElems)
1241
1242def MonsterAddAnyUniqueType(builder, anyUniqueType):
1243    builder.PrependUint8Slot(43, anyUniqueType, 0)
1244
1245def AddAnyUniqueType(builder, anyUniqueType):
1246    MonsterAddAnyUniqueType(builder, anyUniqueType)
1247
1248def MonsterAddAnyUnique(builder, anyUnique):
1249    builder.PrependUOffsetTRelativeSlot(44, flatbuffers.number_types.UOffsetTFlags.py_type(anyUnique), 0)
1250
1251def AddAnyUnique(builder, anyUnique):
1252    MonsterAddAnyUnique(builder, anyUnique)
1253
1254def MonsterAddAnyAmbiguousType(builder, anyAmbiguousType):
1255    builder.PrependUint8Slot(45, anyAmbiguousType, 0)
1256
1257def AddAnyAmbiguousType(builder, anyAmbiguousType):
1258    MonsterAddAnyAmbiguousType(builder, anyAmbiguousType)
1259
1260def MonsterAddAnyAmbiguous(builder, anyAmbiguous):
1261    builder.PrependUOffsetTRelativeSlot(46, flatbuffers.number_types.UOffsetTFlags.py_type(anyAmbiguous), 0)
1262
1263def AddAnyAmbiguous(builder, anyAmbiguous):
1264    MonsterAddAnyAmbiguous(builder, anyAmbiguous)
1265
1266def MonsterAddVectorOfEnums(builder, vectorOfEnums):
1267    builder.PrependUOffsetTRelativeSlot(47, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfEnums), 0)
1268
1269def AddVectorOfEnums(builder, vectorOfEnums):
1270    MonsterAddVectorOfEnums(builder, vectorOfEnums)
1271
1272def MonsterStartVectorOfEnumsVector(builder, numElems):
1273    return builder.StartVector(1, numElems, 1)
1274
1275def StartVectorOfEnumsVector(builder, numElems):
1276    return MonsterStartVectorOfEnumsVector(builder, numElems)
1277
1278def MonsterAddSignedEnum(builder, signedEnum):
1279    builder.PrependInt8Slot(48, signedEnum, -1)
1280
1281def AddSignedEnum(builder, signedEnum):
1282    MonsterAddSignedEnum(builder, signedEnum)
1283
1284def MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer):
1285    builder.PrependUOffsetTRelativeSlot(49, flatbuffers.number_types.UOffsetTFlags.py_type(testrequirednestedflatbuffer), 0)
1286
1287def AddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer):
1288    MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer)
1289
1290def MonsterStartTestrequirednestedflatbufferVector(builder, numElems):
1291    return builder.StartVector(1, numElems, 1)
1292
1293def StartTestrequirednestedflatbufferVector(builder, numElems):
1294    return MonsterStartTestrequirednestedflatbufferVector(builder, numElems)
1295
1296def MonsterMakeTestrequirednestedflatbufferVectorFromBytes(builder, bytes):
1297    builder.StartVector(1, len(bytes), 1)
1298    builder.head = builder.head - len(bytes)
1299    builder.Bytes[builder.head : builder.head + len(bytes)] = bytes
1300    return builder.EndVector()
1301def MakeTestrequirednestedflatbufferVectorFromBytes(builder, bytes):
1302    return MonsterMakeTestrequirednestedflatbufferVectorFromBytes(builder, bytes)
1303def MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables):
1304    builder.PrependUOffsetTRelativeSlot(50, flatbuffers.number_types.UOffsetTFlags.py_type(scalarKeySortedTables), 0)
1305
1306def AddScalarKeySortedTables(builder, scalarKeySortedTables):
1307    MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables)
1308
1309def MonsterStartScalarKeySortedTablesVector(builder, numElems):
1310    return builder.StartVector(4, numElems, 4)
1311
1312def StartScalarKeySortedTablesVector(builder, numElems):
1313    return MonsterStartScalarKeySortedTablesVector(builder, numElems)
1314
1315def MonsterAddNativeInline(builder, nativeInline):
1316    builder.PrependStructSlot(51, flatbuffers.number_types.UOffsetTFlags.py_type(nativeInline), 0)
1317
1318def AddNativeInline(builder, nativeInline):
1319    MonsterAddNativeInline(builder, nativeInline)
1320
1321def MonsterAddLongEnumNonEnumDefault(builder, longEnumNonEnumDefault):
1322    builder.PrependUint64Slot(52, longEnumNonEnumDefault, 0)
1323
1324def AddLongEnumNonEnumDefault(builder, longEnumNonEnumDefault):
1325    MonsterAddLongEnumNonEnumDefault(builder, longEnumNonEnumDefault)
1326
1327def MonsterAddLongEnumNormalDefault(builder, longEnumNormalDefault):
1328    builder.PrependUint64Slot(53, longEnumNormalDefault, 2)
1329
1330def AddLongEnumNormalDefault(builder, longEnumNormalDefault):
1331    MonsterAddLongEnumNormalDefault(builder, longEnumNormalDefault)
1332
1333def MonsterAddNanDefault(builder, nanDefault):
1334    builder.PrependFloat32Slot(54, nanDefault, float('nan'))
1335
1336def AddNanDefault(builder, nanDefault):
1337    MonsterAddNanDefault(builder, nanDefault)
1338
1339def MonsterAddInfDefault(builder, infDefault):
1340    builder.PrependFloat32Slot(55, infDefault, float('inf'))
1341
1342def AddInfDefault(builder, infDefault):
1343    MonsterAddInfDefault(builder, infDefault)
1344
1345def MonsterAddPositiveInfDefault(builder, positiveInfDefault):
1346    builder.PrependFloat32Slot(56, positiveInfDefault, float('inf'))
1347
1348def AddPositiveInfDefault(builder, positiveInfDefault):
1349    MonsterAddPositiveInfDefault(builder, positiveInfDefault)
1350
1351def MonsterAddInfinityDefault(builder, infinityDefault):
1352    builder.PrependFloat32Slot(57, infinityDefault, float('inf'))
1353
1354def AddInfinityDefault(builder, infinityDefault):
1355    MonsterAddInfinityDefault(builder, infinityDefault)
1356
1357def MonsterAddPositiveInfinityDefault(builder, positiveInfinityDefault):
1358    builder.PrependFloat32Slot(58, positiveInfinityDefault, float('inf'))
1359
1360def AddPositiveInfinityDefault(builder, positiveInfinityDefault):
1361    MonsterAddPositiveInfinityDefault(builder, positiveInfinityDefault)
1362
1363def MonsterAddNegativeInfDefault(builder, negativeInfDefault):
1364    builder.PrependFloat32Slot(59, negativeInfDefault, float('-inf'))
1365
1366def AddNegativeInfDefault(builder, negativeInfDefault):
1367    MonsterAddNegativeInfDefault(builder, negativeInfDefault)
1368
1369def MonsterAddNegativeInfinityDefault(builder, negativeInfinityDefault):
1370    builder.PrependFloat32Slot(60, negativeInfinityDefault, float('-inf'))
1371
1372def AddNegativeInfinityDefault(builder, negativeInfinityDefault):
1373    MonsterAddNegativeInfinityDefault(builder, negativeInfinityDefault)
1374
1375def MonsterAddDoubleInfDefault(builder, doubleInfDefault):
1376    builder.PrependFloat64Slot(61, doubleInfDefault, float('inf'))
1377
1378def AddDoubleInfDefault(builder, doubleInfDefault):
1379    MonsterAddDoubleInfDefault(builder, doubleInfDefault)
1380
1381def MonsterEnd(builder):
1382    return builder.EndObject()
1383
1384def End(builder):
1385    return MonsterEnd(builder)
1386
1387import MyGame.Example.Ability
1388import MyGame.Example.Any
1389import MyGame.Example.AnyAmbiguousAliases
1390import MyGame.Example.AnyUniqueAliases
1391import MyGame.Example.Referrable
1392import MyGame.Example.Stat
1393import MyGame.Example.Test
1394import MyGame.Example.TestSimpleTableWithEnum
1395import MyGame.Example.Vec3
1396import MyGame.Example2.Monster
1397import MyGame.InParentNamespace
1398try:
1399    from typing import List, Optional, Union
1400except:
1401    pass
1402
1403class MonsterT(object):
1404
1405    # MonsterT
1406    def __init__(self):
1407        self.pos = None  # type: Optional[MyGame.Example.Vec3.Vec3T]
1408        self.mana = 150  # type: int
1409        self.hp = 100  # type: int
1410        self.name = None  # type: str
1411        self.inventory = None  # type: List[int]
1412        self.color = 8  # type: int
1413        self.testType = 0  # type: int
1414        self.test = None  # type: Union[None, MyGame.Example.Monster.MonsterT, MyGame.Example.TestSimpleTableWithEnum.TestSimpleTableWithEnumT, MyGame.Example2.Monster.MonsterT]
1415        self.test4 = None  # type: List[MyGame.Example.Test.TestT]
1416        self.testarrayofstring = None  # type: List[str]
1417        self.testarrayoftables = None  # type: List[MyGame.Example.Monster.MonsterT]
1418        self.enemy = None  # type: Optional[MyGame.Example.Monster.MonsterT]
1419        self.testnestedflatbuffer = None  # type: List[int]
1420        self.testempty = None  # type: Optional[MyGame.Example.Stat.StatT]
1421        self.testbool = False  # type: bool
1422        self.testhashs32Fnv1 = 0  # type: int
1423        self.testhashu32Fnv1 = 0  # type: int
1424        self.testhashs64Fnv1 = 0  # type: int
1425        self.testhashu64Fnv1 = 0  # type: int
1426        self.testhashs32Fnv1a = 0  # type: int
1427        self.testhashu32Fnv1a = 0  # type: int
1428        self.testhashs64Fnv1a = 0  # type: int
1429        self.testhashu64Fnv1a = 0  # type: int
1430        self.testarrayofbools = None  # type: List[bool]
1431        self.testf = 3.14159  # type: float
1432        self.testf2 = 3.0  # type: float
1433        self.testf3 = 0.0  # type: float
1434        self.testarrayofstring2 = None  # type: List[str]
1435        self.testarrayofsortedstruct = None  # type: List[MyGame.Example.Ability.AbilityT]
1436        self.flex = None  # type: List[int]
1437        self.test5 = None  # type: List[MyGame.Example.Test.TestT]
1438        self.vectorOfLongs = None  # type: List[int]
1439        self.vectorOfDoubles = None  # type: List[float]
1440        self.parentNamespaceTest = None  # type: Optional[MyGame.InParentNamespace.InParentNamespaceT]
1441        self.vectorOfReferrables = None  # type: List[MyGame.Example.Referrable.ReferrableT]
1442        self.singleWeakReference = 0  # type: int
1443        self.vectorOfWeakReferences = None  # type: List[int]
1444        self.vectorOfStrongReferrables = None  # type: List[MyGame.Example.Referrable.ReferrableT]
1445        self.coOwningReference = 0  # type: int
1446        self.vectorOfCoOwningReferences = None  # type: List[int]
1447        self.nonOwningReference = 0  # type: int
1448        self.vectorOfNonOwningReferences = None  # type: List[int]
1449        self.anyUniqueType = 0  # type: int
1450        self.anyUnique = None  # type: Union[None, MyGame.Example.Monster.MonsterT, MyGame.Example.TestSimpleTableWithEnum.TestSimpleTableWithEnumT, MyGame.Example2.Monster.MonsterT]
1451        self.anyAmbiguousType = 0  # type: int
1452        self.anyAmbiguous = None  # type: Union[None, MyGame.Example.Monster.MonsterT, MyGame.Example.Monster.MonsterT, MyGame.Example.Monster.MonsterT]
1453        self.vectorOfEnums = None  # type: List[int]
1454        self.signedEnum = -1  # type: int
1455        self.testrequirednestedflatbuffer = None  # type: List[int]
1456        self.scalarKeySortedTables = None  # type: List[MyGame.Example.Stat.StatT]
1457        self.nativeInline = None  # type: Optional[MyGame.Example.Test.TestT]
1458        self.longEnumNonEnumDefault = 0  # type: int
1459        self.longEnumNormalDefault = 2  # type: int
1460        self.nanDefault = float('nan')  # type: float
1461        self.infDefault = float('inf')  # type: float
1462        self.positiveInfDefault = float('inf')  # type: float
1463        self.infinityDefault = float('inf')  # type: float
1464        self.positiveInfinityDefault = float('inf')  # type: float
1465        self.negativeInfDefault = float('-inf')  # type: float
1466        self.negativeInfinityDefault = float('-inf')  # type: float
1467        self.doubleInfDefault = float('inf')  # type: float
1468
1469    @classmethod
1470    def InitFromBuf(cls, buf, pos):
1471        monster = Monster()
1472        monster.Init(buf, pos)
1473        return cls.InitFromObj(monster)
1474
1475    @classmethod
1476    def InitFromPackedBuf(cls, buf, pos=0):
1477        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
1478        return cls.InitFromBuf(buf, pos+n)
1479
1480    @classmethod
1481    def InitFromObj(cls, monster):
1482        x = MonsterT()
1483        x._UnPack(monster)
1484        return x
1485
1486    # MonsterT
1487    def _UnPack(self, monster):
1488        if monster is None:
1489            return
1490        if monster.Pos() is not None:
1491            self.pos = MyGame.Example.Vec3.Vec3T.InitFromObj(monster.Pos())
1492        self.mana = monster.Mana()
1493        self.hp = monster.Hp()
1494        self.name = monster.Name()
1495        if not monster.InventoryIsNone():
1496            if np is None:
1497                self.inventory = []
1498                for i in range(monster.InventoryLength()):
1499                    self.inventory.append(monster.Inventory(i))
1500            else:
1501                self.inventory = monster.InventoryAsNumpy()
1502        self.color = monster.Color()
1503        self.testType = monster.TestType()
1504        self.test = MyGame.Example.Any.AnyCreator(self.testType, monster.Test())
1505        if not monster.Test4IsNone():
1506            self.test4 = []
1507            for i in range(monster.Test4Length()):
1508                if monster.Test4(i) is None:
1509                    self.test4.append(None)
1510                else:
1511                    test_ = MyGame.Example.Test.TestT.InitFromObj(monster.Test4(i))
1512                    self.test4.append(test_)
1513        if not monster.TestarrayofstringIsNone():
1514            self.testarrayofstring = []
1515            for i in range(monster.TestarrayofstringLength()):
1516                self.testarrayofstring.append(monster.Testarrayofstring(i))
1517        if not monster.TestarrayoftablesIsNone():
1518            self.testarrayoftables = []
1519            for i in range(monster.TestarrayoftablesLength()):
1520                if monster.Testarrayoftables(i) is None:
1521                    self.testarrayoftables.append(None)
1522                else:
1523                    monster_ = MyGame.Example.Monster.MonsterT.InitFromObj(monster.Testarrayoftables(i))
1524                    self.testarrayoftables.append(monster_)
1525        if monster.Enemy() is not None:
1526            self.enemy = MyGame.Example.Monster.MonsterT.InitFromObj(monster.Enemy())
1527        if not monster.TestnestedflatbufferIsNone():
1528            if np is None:
1529                self.testnestedflatbuffer = []
1530                for i in range(monster.TestnestedflatbufferLength()):
1531                    self.testnestedflatbuffer.append(monster.Testnestedflatbuffer(i))
1532            else:
1533                self.testnestedflatbuffer = monster.TestnestedflatbufferAsNumpy()
1534        if monster.Testempty() is not None:
1535            self.testempty = MyGame.Example.Stat.StatT.InitFromObj(monster.Testempty())
1536        self.testbool = monster.Testbool()
1537        self.testhashs32Fnv1 = monster.Testhashs32Fnv1()
1538        self.testhashu32Fnv1 = monster.Testhashu32Fnv1()
1539        self.testhashs64Fnv1 = monster.Testhashs64Fnv1()
1540        self.testhashu64Fnv1 = monster.Testhashu64Fnv1()
1541        self.testhashs32Fnv1a = monster.Testhashs32Fnv1a()
1542        self.testhashu32Fnv1a = monster.Testhashu32Fnv1a()
1543        self.testhashs64Fnv1a = monster.Testhashs64Fnv1a()
1544        self.testhashu64Fnv1a = monster.Testhashu64Fnv1a()
1545        if not monster.TestarrayofboolsIsNone():
1546            if np is None:
1547                self.testarrayofbools = []
1548                for i in range(monster.TestarrayofboolsLength()):
1549                    self.testarrayofbools.append(monster.Testarrayofbools(i))
1550            else:
1551                self.testarrayofbools = monster.TestarrayofboolsAsNumpy()
1552        self.testf = monster.Testf()
1553        self.testf2 = monster.Testf2()
1554        self.testf3 = monster.Testf3()
1555        if not monster.Testarrayofstring2IsNone():
1556            self.testarrayofstring2 = []
1557            for i in range(monster.Testarrayofstring2Length()):
1558                self.testarrayofstring2.append(monster.Testarrayofstring2(i))
1559        if not monster.TestarrayofsortedstructIsNone():
1560            self.testarrayofsortedstruct = []
1561            for i in range(monster.TestarrayofsortedstructLength()):
1562                if monster.Testarrayofsortedstruct(i) is None:
1563                    self.testarrayofsortedstruct.append(None)
1564                else:
1565                    ability_ = MyGame.Example.Ability.AbilityT.InitFromObj(monster.Testarrayofsortedstruct(i))
1566                    self.testarrayofsortedstruct.append(ability_)
1567        if not monster.FlexIsNone():
1568            if np is None:
1569                self.flex = []
1570                for i in range(monster.FlexLength()):
1571                    self.flex.append(monster.Flex(i))
1572            else:
1573                self.flex = monster.FlexAsNumpy()
1574        if not monster.Test5IsNone():
1575            self.test5 = []
1576            for i in range(monster.Test5Length()):
1577                if monster.Test5(i) is None:
1578                    self.test5.append(None)
1579                else:
1580                    test_ = MyGame.Example.Test.TestT.InitFromObj(monster.Test5(i))
1581                    self.test5.append(test_)
1582        if not monster.VectorOfLongsIsNone():
1583            if np is None:
1584                self.vectorOfLongs = []
1585                for i in range(monster.VectorOfLongsLength()):
1586                    self.vectorOfLongs.append(monster.VectorOfLongs(i))
1587            else:
1588                self.vectorOfLongs = monster.VectorOfLongsAsNumpy()
1589        if not monster.VectorOfDoublesIsNone():
1590            if np is None:
1591                self.vectorOfDoubles = []
1592                for i in range(monster.VectorOfDoublesLength()):
1593                    self.vectorOfDoubles.append(monster.VectorOfDoubles(i))
1594            else:
1595                self.vectorOfDoubles = monster.VectorOfDoublesAsNumpy()
1596        if monster.ParentNamespaceTest() is not None:
1597            self.parentNamespaceTest = MyGame.InParentNamespace.InParentNamespaceT.InitFromObj(monster.ParentNamespaceTest())
1598        if not monster.VectorOfReferrablesIsNone():
1599            self.vectorOfReferrables = []
1600            for i in range(monster.VectorOfReferrablesLength()):
1601                if monster.VectorOfReferrables(i) is None:
1602                    self.vectorOfReferrables.append(None)
1603                else:
1604                    referrable_ = MyGame.Example.Referrable.ReferrableT.InitFromObj(monster.VectorOfReferrables(i))
1605                    self.vectorOfReferrables.append(referrable_)
1606        self.singleWeakReference = monster.SingleWeakReference()
1607        if not monster.VectorOfWeakReferencesIsNone():
1608            if np is None:
1609                self.vectorOfWeakReferences = []
1610                for i in range(monster.VectorOfWeakReferencesLength()):
1611                    self.vectorOfWeakReferences.append(monster.VectorOfWeakReferences(i))
1612            else:
1613                self.vectorOfWeakReferences = monster.VectorOfWeakReferencesAsNumpy()
1614        if not monster.VectorOfStrongReferrablesIsNone():
1615            self.vectorOfStrongReferrables = []
1616            for i in range(monster.VectorOfStrongReferrablesLength()):
1617                if monster.VectorOfStrongReferrables(i) is None:
1618                    self.vectorOfStrongReferrables.append(None)
1619                else:
1620                    referrable_ = MyGame.Example.Referrable.ReferrableT.InitFromObj(monster.VectorOfStrongReferrables(i))
1621                    self.vectorOfStrongReferrables.append(referrable_)
1622        self.coOwningReference = monster.CoOwningReference()
1623        if not monster.VectorOfCoOwningReferencesIsNone():
1624            if np is None:
1625                self.vectorOfCoOwningReferences = []
1626                for i in range(monster.VectorOfCoOwningReferencesLength()):
1627                    self.vectorOfCoOwningReferences.append(monster.VectorOfCoOwningReferences(i))
1628            else:
1629                self.vectorOfCoOwningReferences = monster.VectorOfCoOwningReferencesAsNumpy()
1630        self.nonOwningReference = monster.NonOwningReference()
1631        if not monster.VectorOfNonOwningReferencesIsNone():
1632            if np is None:
1633                self.vectorOfNonOwningReferences = []
1634                for i in range(monster.VectorOfNonOwningReferencesLength()):
1635                    self.vectorOfNonOwningReferences.append(monster.VectorOfNonOwningReferences(i))
1636            else:
1637                self.vectorOfNonOwningReferences = monster.VectorOfNonOwningReferencesAsNumpy()
1638        self.anyUniqueType = monster.AnyUniqueType()
1639        self.anyUnique = MyGame.Example.AnyUniqueAliases.AnyUniqueAliasesCreator(self.anyUniqueType, monster.AnyUnique())
1640        self.anyAmbiguousType = monster.AnyAmbiguousType()
1641        self.anyAmbiguous = MyGame.Example.AnyAmbiguousAliases.AnyAmbiguousAliasesCreator(self.anyAmbiguousType, monster.AnyAmbiguous())
1642        if not monster.VectorOfEnumsIsNone():
1643            if np is None:
1644                self.vectorOfEnums = []
1645                for i in range(monster.VectorOfEnumsLength()):
1646                    self.vectorOfEnums.append(monster.VectorOfEnums(i))
1647            else:
1648                self.vectorOfEnums = monster.VectorOfEnumsAsNumpy()
1649        self.signedEnum = monster.SignedEnum()
1650        if not monster.TestrequirednestedflatbufferIsNone():
1651            if np is None:
1652                self.testrequirednestedflatbuffer = []
1653                for i in range(monster.TestrequirednestedflatbufferLength()):
1654                    self.testrequirednestedflatbuffer.append(monster.Testrequirednestedflatbuffer(i))
1655            else:
1656                self.testrequirednestedflatbuffer = monster.TestrequirednestedflatbufferAsNumpy()
1657        if not monster.ScalarKeySortedTablesIsNone():
1658            self.scalarKeySortedTables = []
1659            for i in range(monster.ScalarKeySortedTablesLength()):
1660                if monster.ScalarKeySortedTables(i) is None:
1661                    self.scalarKeySortedTables.append(None)
1662                else:
1663                    stat_ = MyGame.Example.Stat.StatT.InitFromObj(monster.ScalarKeySortedTables(i))
1664                    self.scalarKeySortedTables.append(stat_)
1665        if monster.NativeInline() is not None:
1666            self.nativeInline = MyGame.Example.Test.TestT.InitFromObj(monster.NativeInline())
1667        self.longEnumNonEnumDefault = monster.LongEnumNonEnumDefault()
1668        self.longEnumNormalDefault = monster.LongEnumNormalDefault()
1669        self.nanDefault = monster.NanDefault()
1670        self.infDefault = monster.InfDefault()
1671        self.positiveInfDefault = monster.PositiveInfDefault()
1672        self.infinityDefault = monster.InfinityDefault()
1673        self.positiveInfinityDefault = monster.PositiveInfinityDefault()
1674        self.negativeInfDefault = monster.NegativeInfDefault()
1675        self.negativeInfinityDefault = monster.NegativeInfinityDefault()
1676        self.doubleInfDefault = monster.DoubleInfDefault()
1677
1678    # MonsterT
1679    def Pack(self, builder):
1680        if self.name is not None:
1681            name = builder.CreateString(self.name)
1682        if self.inventory is not None:
1683            if np is not None and type(self.inventory) is np.ndarray:
1684                inventory = builder.CreateNumpyVector(self.inventory)
1685            else:
1686                MonsterStartInventoryVector(builder, len(self.inventory))
1687                for i in reversed(range(len(self.inventory))):
1688                    builder.PrependUint8(self.inventory[i])
1689                inventory = builder.EndVector()
1690        if self.test is not None:
1691            test = self.test.Pack(builder)
1692        if self.test4 is not None:
1693            MonsterStartTest4Vector(builder, len(self.test4))
1694            for i in reversed(range(len(self.test4))):
1695                self.test4[i].Pack(builder)
1696            test4 = builder.EndVector()
1697        if self.testarrayofstring is not None:
1698            testarrayofstringlist = []
1699            for i in range(len(self.testarrayofstring)):
1700                testarrayofstringlist.append(builder.CreateString(self.testarrayofstring[i]))
1701            MonsterStartTestarrayofstringVector(builder, len(self.testarrayofstring))
1702            for i in reversed(range(len(self.testarrayofstring))):
1703                builder.PrependUOffsetTRelative(testarrayofstringlist[i])
1704            testarrayofstring = builder.EndVector()
1705        if self.testarrayoftables is not None:
1706            testarrayoftableslist = []
1707            for i in range(len(self.testarrayoftables)):
1708                testarrayoftableslist.append(self.testarrayoftables[i].Pack(builder))
1709            MonsterStartTestarrayoftablesVector(builder, len(self.testarrayoftables))
1710            for i in reversed(range(len(self.testarrayoftables))):
1711                builder.PrependUOffsetTRelative(testarrayoftableslist[i])
1712            testarrayoftables = builder.EndVector()
1713        if self.enemy is not None:
1714            enemy = self.enemy.Pack(builder)
1715        if self.testnestedflatbuffer is not None:
1716            if np is not None and type(self.testnestedflatbuffer) is np.ndarray:
1717                testnestedflatbuffer = builder.CreateNumpyVector(self.testnestedflatbuffer)
1718            else:
1719                MonsterStartTestnestedflatbufferVector(builder, len(self.testnestedflatbuffer))
1720                for i in reversed(range(len(self.testnestedflatbuffer))):
1721                    builder.PrependUint8(self.testnestedflatbuffer[i])
1722                testnestedflatbuffer = builder.EndVector()
1723        if self.testempty is not None:
1724            testempty = self.testempty.Pack(builder)
1725        if self.testarrayofbools is not None:
1726            if np is not None and type(self.testarrayofbools) is np.ndarray:
1727                testarrayofbools = builder.CreateNumpyVector(self.testarrayofbools)
1728            else:
1729                MonsterStartTestarrayofboolsVector(builder, len(self.testarrayofbools))
1730                for i in reversed(range(len(self.testarrayofbools))):
1731                    builder.PrependBool(self.testarrayofbools[i])
1732                testarrayofbools = builder.EndVector()
1733        if self.testarrayofstring2 is not None:
1734            testarrayofstring2list = []
1735            for i in range(len(self.testarrayofstring2)):
1736                testarrayofstring2list.append(builder.CreateString(self.testarrayofstring2[i]))
1737            MonsterStartTestarrayofstring2Vector(builder, len(self.testarrayofstring2))
1738            for i in reversed(range(len(self.testarrayofstring2))):
1739                builder.PrependUOffsetTRelative(testarrayofstring2list[i])
1740            testarrayofstring2 = builder.EndVector()
1741        if self.testarrayofsortedstruct is not None:
1742            MonsterStartTestarrayofsortedstructVector(builder, len(self.testarrayofsortedstruct))
1743            for i in reversed(range(len(self.testarrayofsortedstruct))):
1744                self.testarrayofsortedstruct[i].Pack(builder)
1745            testarrayofsortedstruct = builder.EndVector()
1746        if self.flex is not None:
1747            if np is not None and type(self.flex) is np.ndarray:
1748                flex = builder.CreateNumpyVector(self.flex)
1749            else:
1750                MonsterStartFlexVector(builder, len(self.flex))
1751                for i in reversed(range(len(self.flex))):
1752                    builder.PrependUint8(self.flex[i])
1753                flex = builder.EndVector()
1754        if self.test5 is not None:
1755            MonsterStartTest5Vector(builder, len(self.test5))
1756            for i in reversed(range(len(self.test5))):
1757                self.test5[i].Pack(builder)
1758            test5 = builder.EndVector()
1759        if self.vectorOfLongs is not None:
1760            if np is not None and type(self.vectorOfLongs) is np.ndarray:
1761                vectorOfLongs = builder.CreateNumpyVector(self.vectorOfLongs)
1762            else:
1763                MonsterStartVectorOfLongsVector(builder, len(self.vectorOfLongs))
1764                for i in reversed(range(len(self.vectorOfLongs))):
1765                    builder.PrependInt64(self.vectorOfLongs[i])
1766                vectorOfLongs = builder.EndVector()
1767        if self.vectorOfDoubles is not None:
1768            if np is not None and type(self.vectorOfDoubles) is np.ndarray:
1769                vectorOfDoubles = builder.CreateNumpyVector(self.vectorOfDoubles)
1770            else:
1771                MonsterStartVectorOfDoublesVector(builder, len(self.vectorOfDoubles))
1772                for i in reversed(range(len(self.vectorOfDoubles))):
1773                    builder.PrependFloat64(self.vectorOfDoubles[i])
1774                vectorOfDoubles = builder.EndVector()
1775        if self.parentNamespaceTest is not None:
1776            parentNamespaceTest = self.parentNamespaceTest.Pack(builder)
1777        if self.vectorOfReferrables is not None:
1778            vectorOfReferrableslist = []
1779            for i in range(len(self.vectorOfReferrables)):
1780                vectorOfReferrableslist.append(self.vectorOfReferrables[i].Pack(builder))
1781            MonsterStartVectorOfReferrablesVector(builder, len(self.vectorOfReferrables))
1782            for i in reversed(range(len(self.vectorOfReferrables))):
1783                builder.PrependUOffsetTRelative(vectorOfReferrableslist[i])
1784            vectorOfReferrables = builder.EndVector()
1785        if self.vectorOfWeakReferences is not None:
1786            if np is not None and type(self.vectorOfWeakReferences) is np.ndarray:
1787                vectorOfWeakReferences = builder.CreateNumpyVector(self.vectorOfWeakReferences)
1788            else:
1789                MonsterStartVectorOfWeakReferencesVector(builder, len(self.vectorOfWeakReferences))
1790                for i in reversed(range(len(self.vectorOfWeakReferences))):
1791                    builder.PrependUint64(self.vectorOfWeakReferences[i])
1792                vectorOfWeakReferences = builder.EndVector()
1793        if self.vectorOfStrongReferrables is not None:
1794            vectorOfStrongReferrableslist = []
1795            for i in range(len(self.vectorOfStrongReferrables)):
1796                vectorOfStrongReferrableslist.append(self.vectorOfStrongReferrables[i].Pack(builder))
1797            MonsterStartVectorOfStrongReferrablesVector(builder, len(self.vectorOfStrongReferrables))
1798            for i in reversed(range(len(self.vectorOfStrongReferrables))):
1799                builder.PrependUOffsetTRelative(vectorOfStrongReferrableslist[i])
1800            vectorOfStrongReferrables = builder.EndVector()
1801        if self.vectorOfCoOwningReferences is not None:
1802            if np is not None and type(self.vectorOfCoOwningReferences) is np.ndarray:
1803                vectorOfCoOwningReferences = builder.CreateNumpyVector(self.vectorOfCoOwningReferences)
1804            else:
1805                MonsterStartVectorOfCoOwningReferencesVector(builder, len(self.vectorOfCoOwningReferences))
1806                for i in reversed(range(len(self.vectorOfCoOwningReferences))):
1807                    builder.PrependUint64(self.vectorOfCoOwningReferences[i])
1808                vectorOfCoOwningReferences = builder.EndVector()
1809        if self.vectorOfNonOwningReferences is not None:
1810            if np is not None and type(self.vectorOfNonOwningReferences) is np.ndarray:
1811                vectorOfNonOwningReferences = builder.CreateNumpyVector(self.vectorOfNonOwningReferences)
1812            else:
1813                MonsterStartVectorOfNonOwningReferencesVector(builder, len(self.vectorOfNonOwningReferences))
1814                for i in reversed(range(len(self.vectorOfNonOwningReferences))):
1815                    builder.PrependUint64(self.vectorOfNonOwningReferences[i])
1816                vectorOfNonOwningReferences = builder.EndVector()
1817        if self.anyUnique is not None:
1818            anyUnique = self.anyUnique.Pack(builder)
1819        if self.anyAmbiguous is not None:
1820            anyAmbiguous = self.anyAmbiguous.Pack(builder)
1821        if self.vectorOfEnums is not None:
1822            if np is not None and type(self.vectorOfEnums) is np.ndarray:
1823                vectorOfEnums = builder.CreateNumpyVector(self.vectorOfEnums)
1824            else:
1825                MonsterStartVectorOfEnumsVector(builder, len(self.vectorOfEnums))
1826                for i in reversed(range(len(self.vectorOfEnums))):
1827                    builder.PrependUint8(self.vectorOfEnums[i])
1828                vectorOfEnums = builder.EndVector()
1829        if self.testrequirednestedflatbuffer is not None:
1830            if np is not None and type(self.testrequirednestedflatbuffer) is np.ndarray:
1831                testrequirednestedflatbuffer = builder.CreateNumpyVector(self.testrequirednestedflatbuffer)
1832            else:
1833                MonsterStartTestrequirednestedflatbufferVector(builder, len(self.testrequirednestedflatbuffer))
1834                for i in reversed(range(len(self.testrequirednestedflatbuffer))):
1835                    builder.PrependUint8(self.testrequirednestedflatbuffer[i])
1836                testrequirednestedflatbuffer = builder.EndVector()
1837        if self.scalarKeySortedTables is not None:
1838            scalarKeySortedTableslist = []
1839            for i in range(len(self.scalarKeySortedTables)):
1840                scalarKeySortedTableslist.append(self.scalarKeySortedTables[i].Pack(builder))
1841            MonsterStartScalarKeySortedTablesVector(builder, len(self.scalarKeySortedTables))
1842            for i in reversed(range(len(self.scalarKeySortedTables))):
1843                builder.PrependUOffsetTRelative(scalarKeySortedTableslist[i])
1844            scalarKeySortedTables = builder.EndVector()
1845        MonsterStart(builder)
1846        if self.pos is not None:
1847            pos = self.pos.Pack(builder)
1848            MonsterAddPos(builder, pos)
1849        MonsterAddMana(builder, self.mana)
1850        MonsterAddHp(builder, self.hp)
1851        if self.name is not None:
1852            MonsterAddName(builder, name)
1853        if self.inventory is not None:
1854            MonsterAddInventory(builder, inventory)
1855        MonsterAddColor(builder, self.color)
1856        MonsterAddTestType(builder, self.testType)
1857        if self.test is not None:
1858            MonsterAddTest(builder, test)
1859        if self.test4 is not None:
1860            MonsterAddTest4(builder, test4)
1861        if self.testarrayofstring is not None:
1862            MonsterAddTestarrayofstring(builder, testarrayofstring)
1863        if self.testarrayoftables is not None:
1864            MonsterAddTestarrayoftables(builder, testarrayoftables)
1865        if self.enemy is not None:
1866            MonsterAddEnemy(builder, enemy)
1867        if self.testnestedflatbuffer is not None:
1868            MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer)
1869        if self.testempty is not None:
1870            MonsterAddTestempty(builder, testempty)
1871        MonsterAddTestbool(builder, self.testbool)
1872        MonsterAddTesthashs32Fnv1(builder, self.testhashs32Fnv1)
1873        MonsterAddTesthashu32Fnv1(builder, self.testhashu32Fnv1)
1874        MonsterAddTesthashs64Fnv1(builder, self.testhashs64Fnv1)
1875        MonsterAddTesthashu64Fnv1(builder, self.testhashu64Fnv1)
1876        MonsterAddTesthashs32Fnv1a(builder, self.testhashs32Fnv1a)
1877        MonsterAddTesthashu32Fnv1a(builder, self.testhashu32Fnv1a)
1878        MonsterAddTesthashs64Fnv1a(builder, self.testhashs64Fnv1a)
1879        MonsterAddTesthashu64Fnv1a(builder, self.testhashu64Fnv1a)
1880        if self.testarrayofbools is not None:
1881            MonsterAddTestarrayofbools(builder, testarrayofbools)
1882        MonsterAddTestf(builder, self.testf)
1883        MonsterAddTestf2(builder, self.testf2)
1884        MonsterAddTestf3(builder, self.testf3)
1885        if self.testarrayofstring2 is not None:
1886            MonsterAddTestarrayofstring2(builder, testarrayofstring2)
1887        if self.testarrayofsortedstruct is not None:
1888            MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct)
1889        if self.flex is not None:
1890            MonsterAddFlex(builder, flex)
1891        if self.test5 is not None:
1892            MonsterAddTest5(builder, test5)
1893        if self.vectorOfLongs is not None:
1894            MonsterAddVectorOfLongs(builder, vectorOfLongs)
1895        if self.vectorOfDoubles is not None:
1896            MonsterAddVectorOfDoubles(builder, vectorOfDoubles)
1897        if self.parentNamespaceTest is not None:
1898            MonsterAddParentNamespaceTest(builder, parentNamespaceTest)
1899        if self.vectorOfReferrables is not None:
1900            MonsterAddVectorOfReferrables(builder, vectorOfReferrables)
1901        MonsterAddSingleWeakReference(builder, self.singleWeakReference)
1902        if self.vectorOfWeakReferences is not None:
1903            MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences)
1904        if self.vectorOfStrongReferrables is not None:
1905            MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables)
1906        MonsterAddCoOwningReference(builder, self.coOwningReference)
1907        if self.vectorOfCoOwningReferences is not None:
1908            MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences)
1909        MonsterAddNonOwningReference(builder, self.nonOwningReference)
1910        if self.vectorOfNonOwningReferences is not None:
1911            MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences)
1912        MonsterAddAnyUniqueType(builder, self.anyUniqueType)
1913        if self.anyUnique is not None:
1914            MonsterAddAnyUnique(builder, anyUnique)
1915        MonsterAddAnyAmbiguousType(builder, self.anyAmbiguousType)
1916        if self.anyAmbiguous is not None:
1917            MonsterAddAnyAmbiguous(builder, anyAmbiguous)
1918        if self.vectorOfEnums is not None:
1919            MonsterAddVectorOfEnums(builder, vectorOfEnums)
1920        MonsterAddSignedEnum(builder, self.signedEnum)
1921        if self.testrequirednestedflatbuffer is not None:
1922            MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer)
1923        if self.scalarKeySortedTables is not None:
1924            MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables)
1925        if self.nativeInline is not None:
1926            nativeInline = self.nativeInline.Pack(builder)
1927            MonsterAddNativeInline(builder, nativeInline)
1928        MonsterAddLongEnumNonEnumDefault(builder, self.longEnumNonEnumDefault)
1929        MonsterAddLongEnumNormalDefault(builder, self.longEnumNormalDefault)
1930        MonsterAddNanDefault(builder, self.nanDefault)
1931        MonsterAddInfDefault(builder, self.infDefault)
1932        MonsterAddPositiveInfDefault(builder, self.positiveInfDefault)
1933        MonsterAddInfinityDefault(builder, self.infinityDefault)
1934        MonsterAddPositiveInfinityDefault(builder, self.positiveInfinityDefault)
1935        MonsterAddNegativeInfDefault(builder, self.negativeInfDefault)
1936        MonsterAddNegativeInfinityDefault(builder, self.negativeInfinityDefault)
1937        MonsterAddDoubleInfDefault(builder, self.doubleInfDefault)
1938        monster = MonsterEnd(builder)
1939        return monster
1940