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: int) -> int:
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: int) -> int:
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: int) -> int:
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: int) -> int:
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: int) -> int:
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: int) -> int:
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: int) -> int:
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: int) -> int:
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: int) -> int:
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: int) -> int:
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: int) -> int:
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: int) -> int:
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: int) -> int:
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: int) -> int:
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: int) -> int:
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: int) -> int:
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: int) -> int:
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: int) -> int:
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: int) -> int:
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: int) -> int:
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
View as plain text