generated.py - NovaBryan/EVE

generated.py (52682B)
      1 #Embedded file name: C:\BuildAgent\work\20d73f1b24eed06e\eve\release\V24.01\packages\achievement_system\client\model\flatbuffer\generated.py
      2 import flatbuffers
      3 from flatbuffers.compat import import_numpy
      4 np = import_numpy()
      5 
      6 class RewardPayload(object):
      7     NONE = 0
      8     IskReward = 1
      9     SpReward = 2
     10     ItemReward = 3
     11     TitleReward = 4
     12 
     13 
     14 class ProgressConfig(object):
     15     NONE = 0
     16     CumulativeMode = 1
     17     ChecklistMode = 2
     18     SetMode = 3
     19 
     20 
     21 class IskReward(object):
     22     __slots__ = ['_tab']
     23 
     24     @classmethod
     25     def GetRootAs(cls, buf, offset = 0):
     26         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
     27         x = IskReward()
     28         x.Init(buf, n + offset)
     29         return x
     30 
     31     @classmethod
     32     def GetRootAsIskReward(cls, buf, offset = 0):
     33         return cls.GetRootAs(buf, offset)
     34 
     35     @classmethod
     36     def IskRewardBufferHasIdentifier(cls, buf, offset, size_prefixed = False):
     37         return flatbuffers.util.BufferHasIdentifier(buf, offset, 'ACHV', size_prefixed=size_prefixed)
     38 
     39     def Init(self, buf, pos):
     40         self._tab = flatbuffers.table.Table(buf, pos)
     41 
     42     def Quantity(self):
     43         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
     44         if o != 0:
     45             return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
     46         return 0
     47 
     48 
     49 def IskRewardStart(builder):
     50     builder.StartObject(1)
     51 
     52 
     53 def IskRewardAddQuantity(builder, quantity):
     54     builder.PrependUint64Slot(0, quantity, 0)
     55 
     56 
     57 def IskRewardEnd(builder):
     58     return builder.EndObject()
     59 
     60 
     61 class SpReward(object):
     62     __slots__ = ['_tab']
     63 
     64     @classmethod
     65     def GetRootAs(cls, buf, offset = 0):
     66         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
     67         x = SpReward()
     68         x.Init(buf, n + offset)
     69         return x
     70 
     71     @classmethod
     72     def GetRootAsSpReward(cls, buf, offset = 0):
     73         return cls.GetRootAs(buf, offset)
     74 
     75     @classmethod
     76     def SpRewardBufferHasIdentifier(cls, buf, offset, size_prefixed = False):
     77         return flatbuffers.util.BufferHasIdentifier(buf, offset, 'ACHV', size_prefixed=size_prefixed)
     78 
     79     def Init(self, buf, pos):
     80         self._tab = flatbuffers.table.Table(buf, pos)
     81 
     82     def Quantity(self):
     83         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
     84         if o != 0:
     85             return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
     86         return 0
     87 
     88 
     89 def SpRewardStart(builder):
     90     builder.StartObject(1)
     91 
     92 
     93 def SpRewardAddQuantity(builder, quantity):
     94     builder.PrependUint64Slot(0, quantity, 0)
     95 
     96 
     97 def SpRewardEnd(builder):
     98     return builder.EndObject()
     99 
    100 
    101 class ItemReward(object):
    102     __slots__ = ['_tab']
    103 
    104     @classmethod
    105     def GetRootAs(cls, buf, offset = 0):
    106         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
    107         x = ItemReward()
    108         x.Init(buf, n + offset)
    109         return x
    110 
    111     @classmethod
    112     def GetRootAsItemReward(cls, buf, offset = 0):
    113         return cls.GetRootAs(buf, offset)
    114 
    115     @classmethod
    116     def ItemRewardBufferHasIdentifier(cls, buf, offset, size_prefixed = False):
    117         return flatbuffers.util.BufferHasIdentifier(buf, offset, 'ACHV', size_prefixed=size_prefixed)
    118 
    119     def Init(self, buf, pos):
    120         self._tab = flatbuffers.table.Table(buf, pos)
    121 
    122     def TypeId(self):
    123         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
    124         if o != 0:
    125             return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
    126         return 0
    127 
    128     def Quantity(self):
    129         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    130         if o != 0:
    131             return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
    132         return 0
    133 
    134 
    135 def ItemRewardStart(builder):
    136     builder.StartObject(2)
    137 
    138 
    139 def ItemRewardAddTypeId(builder, typeId):
    140     builder.PrependUint32Slot(0, typeId, 0)
    141 
    142 
    143 def ItemRewardAddQuantity(builder, quantity):
    144     builder.PrependUint64Slot(1, quantity, 0)
    145 
    146 
    147 def ItemRewardEnd(builder):
    148     return builder.EndObject()
    149 
    150 
    151 class TitleReward(object):
    152     __slots__ = ['_tab']
    153 
    154     @classmethod
    155     def GetRootAs(cls, buf, offset = 0):
    156         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
    157         x = TitleReward()
    158         x.Init(buf, n + offset)
    159         return x
    160 
    161     @classmethod
    162     def GetRootAsTitleReward(cls, buf, offset = 0):
    163         return cls.GetRootAs(buf, offset)
    164 
    165     @classmethod
    166     def TitleRewardBufferHasIdentifier(cls, buf, offset, size_prefixed = False):
    167         return flatbuffers.util.BufferHasIdentifier(buf, offset, 'ACHV', size_prefixed=size_prefixed)
    168 
    169     def Init(self, buf, pos):
    170         self._tab = flatbuffers.table.Table(buf, pos)
    171 
    172     def TitleId(self):
    173         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
    174         if o != 0:
    175             return self._tab.String(o + self._tab.Pos)
    176 
    177 
    178 def TitleRewardStart(builder):
    179     builder.StartObject(1)
    180 
    181 
    182 def TitleRewardAddTitleId(builder, titleId):
    183     builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(titleId), 0)
    184 
    185 
    186 def TitleRewardEnd(builder):
    187     return builder.EndObject()
    188 
    189 
    190 class Reward(object):
    191     __slots__ = ['_tab']
    192 
    193     @classmethod
    194     def GetRootAs(cls, buf, offset = 0):
    195         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
    196         x = Reward()
    197         x.Init(buf, n + offset)
    198         return x
    199 
    200     @classmethod
    201     def GetRootAsReward(cls, buf, offset = 0):
    202         return cls.GetRootAs(buf, offset)
    203 
    204     @classmethod
    205     def RewardBufferHasIdentifier(cls, buf, offset, size_prefixed = False):
    206         return flatbuffers.util.BufferHasIdentifier(buf, offset, 'ACHV', size_prefixed=size_prefixed)
    207 
    208     def Init(self, buf, pos):
    209         self._tab = flatbuffers.table.Table(buf, pos)
    210 
    211     def Id(self):
    212         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
    213         if o != 0:
    214             return self._tab.String(o + self._tab.Pos)
    215 
    216     def PayloadType(self):
    217         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    218         if o != 0:
    219             return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
    220         return 0
    221 
    222     def Payload(self):
    223         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
    224         if o != 0:
    225             from flatbuffers.table import Table
    226             obj = Table(bytearray(), 0)
    227             self._tab.Union(obj, o)
    228             return obj
    229 
    230     def InternalName(self):
    231         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
    232         if o != 0:
    233             return self._tab.String(o + self._tab.Pos)
    234 
    235 
    236 def RewardStart(builder):
    237     builder.StartObject(4)
    238 
    239 
    240 def RewardAddId(builder, id):
    241     builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(id), 0)
    242 
    243 
    244 def RewardAddPayloadType(builder, payloadType):
    245     builder.PrependUint8Slot(1, payloadType, 0)
    246 
    247 
    248 def RewardAddPayload(builder, payload):
    249     builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(payload), 0)
    250 
    251 
    252 def RewardAddInternalName(builder, internalName):
    253     builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(internalName), 0)
    254 
    255 
    256 def RewardEnd(builder):
    257     return builder.EndObject()
    258 
    259 
    260 class AchievementMilestone(object):
    261     __slots__ = ['_tab']
    262 
    263     @classmethod
    264     def GetRootAs(cls, buf, offset = 0):
    265         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
    266         x = AchievementMilestone()
    267         x.Init(buf, n + offset)
    268         return x
    269 
    270     @classmethod
    271     def GetRootAsAchievementMilestone(cls, buf, offset = 0):
    272         return cls.GetRootAs(buf, offset)
    273 
    274     @classmethod
    275     def AchievementMilestoneBufferHasIdentifier(cls, buf, offset, size_prefixed = False):
    276         return flatbuffers.util.BufferHasIdentifier(buf, offset, 'ACHV', size_prefixed=size_prefixed)
    277 
    278     def Init(self, buf, pos):
    279         self._tab = flatbuffers.table.Table(buf, pos)
    280 
    281     def Id(self):
    282         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
    283         if o != 0:
    284             return self._tab.String(o + self._tab.Pos)
    285 
    286     def Target(self):
    287         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    288         if o != 0:
    289             return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
    290         return 0
    291 
    292     def CategoryPoints(self):
    293         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
    294         if o != 0:
    295             return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
    296         return 0
    297 
    298     def Rewards(self, j):
    299         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
    300         if o != 0:
    301             x = self._tab.Vector(o)
    302             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
    303             x = self._tab.Indirect(x)
    304             obj = Reward()
    305             obj.Init(self._tab.Bytes, x)
    306             return obj
    307 
    308     def RewardsLength(self):
    309         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
    310         if o != 0:
    311             return self._tab.VectorLen(o)
    312         return 0
    313 
    314     def RewardsIsNone(self):
    315         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
    316         return o == 0
    317 
    318     def InternalName(self):
    319         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
    320         if o != 0:
    321             return self._tab.String(o + self._tab.Pos)
    322 
    323 
    324 def AchievementMilestoneStart(builder):
    325     builder.StartObject(5)
    326 
    327 
    328 def AchievementMilestoneAddId(builder, id):
    329     builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(id), 0)
    330 
    331 
    332 def AchievementMilestoneAddTarget(builder, target):
    333     builder.PrependUint64Slot(1, target, 0)
    334 
    335 
    336 def AchievementMilestoneAddCategoryPoints(builder, categoryPoints):
    337     builder.PrependUint32Slot(2, categoryPoints, 0)
    338 
    339 
    340 def AchievementMilestoneAddRewards(builder, rewards):
    341     builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(rewards), 0)
    342 
    343 
    344 def AchievementMilestoneStartRewardsVector(builder, numElems):
    345     return builder.StartVector(4, numElems, 4)
    346 
    347 
    348 def AchievementMilestoneCreateRewardsVector(builder, data):
    349     return builder.CreateVectorOfTables(data)
    350 
    351 
    352 def AchievementMilestoneAddInternalName(builder, internalName):
    353     builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(internalName), 0)
    354 
    355 
    356 def AchievementMilestoneEnd(builder):
    357     return builder.EndObject()
    358 
    359 
    360 class CategoryMilestone(object):
    361     __slots__ = ['_tab']
    362 
    363     @classmethod
    364     def GetRootAs(cls, buf, offset = 0):
    365         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
    366         x = CategoryMilestone()
    367         x.Init(buf, n + offset)
    368         return x
    369 
    370     @classmethod
    371     def GetRootAsCategoryMilestone(cls, buf, offset = 0):
    372         return cls.GetRootAs(buf, offset)
    373 
    374     @classmethod
    375     def CategoryMilestoneBufferHasIdentifier(cls, buf, offset, size_prefixed = False):
    376         return flatbuffers.util.BufferHasIdentifier(buf, offset, 'ACHV', size_prefixed=size_prefixed)
    377 
    378     def Init(self, buf, pos):
    379         self._tab = flatbuffers.table.Table(buf, pos)
    380 
    381     def Id(self):
    382         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
    383         if o != 0:
    384             return self._tab.String(o + self._tab.Pos)
    385 
    386     def Target(self):
    387         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    388         if o != 0:
    389             return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
    390         return 0
    391 
    392     def Rewards(self, j):
    393         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
    394         if o != 0:
    395             x = self._tab.Vector(o)
    396             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
    397             x = self._tab.Indirect(x)
    398             obj = Reward()
    399             obj.Init(self._tab.Bytes, x)
    400             return obj
    401 
    402     def RewardsLength(self):
    403         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
    404         if o != 0:
    405             return self._tab.VectorLen(o)
    406         return 0
    407 
    408     def RewardsIsNone(self):
    409         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
    410         return o == 0
    411 
    412     def InternalName(self):
    413         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
    414         if o != 0:
    415             return self._tab.String(o + self._tab.Pos)
    416 
    417 
    418 def CategoryMilestoneStart(builder):
    419     builder.StartObject(4)
    420 
    421 
    422 def CategoryMilestoneAddId(builder, id):
    423     builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(id), 0)
    424 
    425 
    426 def CategoryMilestoneAddTarget(builder, target):
    427     builder.PrependUint32Slot(1, target, 0)
    428 
    429 
    430 def CategoryMilestoneAddRewards(builder, rewards):
    431     builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(rewards), 0)
    432 
    433 
    434 def CategoryMilestoneStartRewardsVector(builder, numElems):
    435     return builder.StartVector(4, numElems, 4)
    436 
    437 
    438 def CategoryMilestoneCreateRewardsVector(builder, data):
    439     return builder.CreateVectorOfTables(data)
    440 
    441 
    442 def CategoryMilestoneAddInternalName(builder, internalName):
    443     builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(internalName), 0)
    444 
    445 
    446 def CategoryMilestoneEnd(builder):
    447     return builder.EndObject()
    448 
    449 
    450 class MethodParamDefinition(object):
    451     __slots__ = ['_tab']
    452 
    453     @classmethod
    454     def GetRootAs(cls, buf, offset = 0):
    455         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
    456         x = MethodParamDefinition()
    457         x.Init(buf, n + offset)
    458         return x
    459 
    460     @classmethod
    461     def GetRootAsMethodParamDefinition(cls, buf, offset = 0):
    462         return cls.GetRootAs(buf, offset)
    463 
    464     @classmethod
    465     def MethodParamDefinitionBufferHasIdentifier(cls, buf, offset, size_prefixed = False):
    466         return flatbuffers.util.BufferHasIdentifier(buf, offset, 'ACHV', size_prefixed=size_prefixed)
    467 
    468     def Init(self, buf, pos):
    469         self._tab = flatbuffers.table.Table(buf, pos)
    470 
    471     def Key(self):
    472         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
    473         if o != 0:
    474             return self._tab.String(o + self._tab.Pos)
    475 
    476     def Type(self):
    477         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    478         if o != 0:
    479             return self._tab.String(o + self._tab.Pos)
    480 
    481     def AcceptedValueTypes(self, j):
    482         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
    483         if o != 0:
    484             a = self._tab.Vector(o)
    485             return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
    486         return ''
    487 
    488     def AcceptedValueTypesLength(self):
    489         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
    490         if o != 0:
    491             return self._tab.VectorLen(o)
    492         return 0
    493 
    494     def AcceptedValueTypesIsNone(self):
    495         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
    496         return o == 0
    497 
    498     def Optional(self):
    499         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
    500         if o != 0:
    501             return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
    502         return False
    503 
    504     def Name(self):
    505         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
    506         if o != 0:
    507             return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
    508         return 0
    509 
    510     def Description(self):
    511         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
    512         if o != 0:
    513             return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
    514         return 0
    515 
    516     def IconId(self):
    517         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
    518         if o != 0:
    519             return self._tab.String(o + self._tab.Pos)
    520 
    521 
    522 def MethodParamDefinitionStart(builder):
    523     builder.StartObject(7)
    524 
    525 
    526 def MethodParamDefinitionAddKey(builder, key):
    527     builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(key), 0)
    528 
    529 
    530 def MethodParamDefinitionAddType(builder, type):
    531     builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(type), 0)
    532 
    533 
    534 def MethodParamDefinitionAddAcceptedValueTypes(builder, acceptedValueTypes):
    535     builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(acceptedValueTypes), 0)
    536 
    537 
    538 def MethodParamDefinitionStartAcceptedValueTypesVector(builder, numElems):
    539     return builder.StartVector(4, numElems, 4)
    540 
    541 
    542 def MethodParamDefinitionCreateAcceptedValueTypesVector(builder, data):
    543     return builder.CreateVectorOfTables(data)
    544 
    545 
    546 def MethodParamDefinitionAddOptional(builder, optional):
    547     builder.PrependBoolSlot(3, optional, 0)
    548 
    549 
    550 def MethodParamDefinitionAddName(builder, name):
    551     builder.PrependUint32Slot(4, name, 0)
    552 
    553 
    554 def MethodParamDefinitionAddDescription(builder, description):
    555     builder.PrependUint32Slot(5, description, 0)
    556 
    557 
    558 def MethodParamDefinitionAddIconId(builder, iconId):
    559     builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(iconId), 0)
    560 
    561 
    562 def MethodParamDefinitionEnd(builder):
    563     return builder.EndObject()
    564 
    565 
    566 class CumulativeMode(object):
    567     __slots__ = ['_tab']
    568 
    569     @classmethod
    570     def GetRootAs(cls, buf, offset = 0):
    571         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
    572         x = CumulativeMode()
    573         x.Init(buf, n + offset)
    574         return x
    575 
    576     @classmethod
    577     def GetRootAsCumulativeMode(cls, buf, offset = 0):
    578         return cls.GetRootAs(buf, offset)
    579 
    580     @classmethod
    581     def CumulativeModeBufferHasIdentifier(cls, buf, offset, size_prefixed = False):
    582         return flatbuffers.util.BufferHasIdentifier(buf, offset, 'ACHV', size_prefixed=size_prefixed)
    583 
    584     def Init(self, buf, pos):
    585         self._tab = flatbuffers.table.Table(buf, pos)
    586 
    587 
    588 def CumulativeModeStart(builder):
    589     builder.StartObject(0)
    590 
    591 
    592 def CumulativeModeEnd(builder):
    593     return builder.EndObject()
    594 
    595 
    596 class ChecklistMode(object):
    597     __slots__ = ['_tab']
    598 
    599     @classmethod
    600     def GetRootAs(cls, buf, offset = 0):
    601         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
    602         x = ChecklistMode()
    603         x.Init(buf, n + offset)
    604         return x
    605 
    606     @classmethod
    607     def GetRootAsChecklistMode(cls, buf, offset = 0):
    608         return cls.GetRootAs(buf, offset)
    609 
    610     @classmethod
    611     def ChecklistModeBufferHasIdentifier(cls, buf, offset, size_prefixed = False):
    612         return flatbuffers.util.BufferHasIdentifier(buf, offset, 'ACHV', size_prefixed=size_prefixed)
    613 
    614     def Init(self, buf, pos):
    615         self._tab = flatbuffers.table.Table(buf, pos)
    616 
    617     def TargetParameter(self):
    618         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
    619         if o != 0:
    620             return self._tab.String(o + self._tab.Pos)
    621 
    622 
    623 def ChecklistModeStart(builder):
    624     builder.StartObject(1)
    625 
    626 
    627 def ChecklistModeAddTargetParameter(builder, targetParameter):
    628     builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(targetParameter), 0)
    629 
    630 
    631 def ChecklistModeEnd(builder):
    632     return builder.EndObject()
    633 
    634 
    635 class SetMode(object):
    636     __slots__ = ['_tab']
    637 
    638     @classmethod
    639     def GetRootAs(cls, buf, offset = 0):
    640         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
    641         x = SetMode()
    642         x.Init(buf, n + offset)
    643         return x
    644 
    645     @classmethod
    646     def GetRootAsSetMode(cls, buf, offset = 0):
    647         return cls.GetRootAs(buf, offset)
    648 
    649     @classmethod
    650     def SetModeBufferHasIdentifier(cls, buf, offset, size_prefixed = False):
    651         return flatbuffers.util.BufferHasIdentifier(buf, offset, 'ACHV', size_prefixed=size_prefixed)
    652 
    653     def Init(self, buf, pos):
    654         self._tab = flatbuffers.table.Table(buf, pos)
    655 
    656     def TargetValueType(self):
    657         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
    658         if o != 0:
    659             return self._tab.String(o + self._tab.Pos)
    660 
    661 
    662 def SetModeStart(builder):
    663     builder.StartObject(1)
    664 
    665 
    666 def SetModeAddTargetValueType(builder, targetValueType):
    667     builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(targetValueType), 0)
    668 
    669 
    670 def SetModeEnd(builder):
    671     return builder.EndObject()
    672 
    673 
    674 class ContributionMethodDefinition(object):
    675     __slots__ = ['_tab']
    676 
    677     @classmethod
    678     def GetRootAs(cls, buf, offset = 0):
    679         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
    680         x = ContributionMethodDefinition()
    681         x.Init(buf, n + offset)
    682         return x
    683 
    684     @classmethod
    685     def GetRootAsContributionMethodDefinition(cls, buf, offset = 0):
    686         return cls.GetRootAs(buf, offset)
    687 
    688     @classmethod
    689     def ContributionMethodDefinitionBufferHasIdentifier(cls, buf, offset, size_prefixed = False):
    690         return flatbuffers.util.BufferHasIdentifier(buf, offset, 'ACHV', size_prefixed=size_prefixed)
    691 
    692     def Init(self, buf, pos):
    693         self._tab = flatbuffers.table.Table(buf, pos)
    694 
    695     def Id(self):
    696         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
    697         if o != 0:
    698             return self._tab.String(o + self._tab.Pos)
    699 
    700     def Name(self):
    701         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    702         if o != 0:
    703             return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
    704         return 0
    705 
    706     def Description(self):
    707         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
    708         if o != 0:
    709             return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
    710         return 0
    711 
    712     def IconId(self):
    713         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
    714         if o != 0:
    715             return self._tab.String(o + self._tab.Pos)
    716 
    717     def ContentTags(self, j):
    718         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
    719         if o != 0:
    720             a = self._tab.Vector(o)
    721             return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
    722         return ''
    723 
    724     def ContentTagsLength(self):
    725         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
    726         if o != 0:
    727             return self._tab.VectorLen(o)
    728         return 0
    729 
    730     def ContentTagsIsNone(self):
    731         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
    732         return o == 0
    733 
    734     def ProgressDescription(self):
    735         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
    736         if o != 0:
    737             return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
    738         return 0
    739 
    740     def Parameters(self, j):
    741         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
    742         if o != 0:
    743             x = self._tab.Vector(o)
    744             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
    745             x = self._tab.Indirect(x)
    746             obj = MethodParamDefinition()
    747             obj.Init(self._tab.Bytes, x)
    748             return obj
    749 
    750     def ParametersLength(self):
    751         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
    752         if o != 0:
    753             return self._tab.VectorLen(o)
    754         return 0
    755 
    756     def ParametersIsNone(self):
    757         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
    758         return o == 0
    759 
    760     def ProgressType(self):
    761         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
    762         if o != 0:
    763             return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
    764         return 0
    765 
    766     def Progress(self):
    767         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
    768         if o != 0:
    769             from flatbuffers.table import Table
    770             obj = Table(bytearray(), 0)
    771             self._tab.Union(obj, o)
    772             return obj
    773 
    774     def UiAnnotations(self, j):
    775         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
    776         if o != 0:
    777             x = self._tab.Vector(o)
    778             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
    779             x = self._tab.Indirect(x)
    780             obj = UiAnnotation()
    781             obj.Init(self._tab.Bytes, x)
    782             return obj
    783 
    784     def UiAnnotationsLength(self):
    785         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
    786         if o != 0:
    787             return self._tab.VectorLen(o)
    788         return 0
    789 
    790     def UiAnnotationsIsNone(self):
    791         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
    792         return o == 0
    793 
    794 
    795 def ContributionMethodDefinitionStart(builder):
    796     builder.StartObject(10)
    797 
    798 
    799 def ContributionMethodDefinitionAddId(builder, id):
    800     builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(id), 0)
    801 
    802 
    803 def ContributionMethodDefinitionAddName(builder, name):
    804     builder.PrependUint32Slot(1, name, 0)
    805 
    806 
    807 def ContributionMethodDefinitionAddDescription(builder, description):
    808     builder.PrependUint32Slot(2, description, 0)
    809 
    810 
    811 def ContributionMethodDefinitionAddIconId(builder, iconId):
    812     builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(iconId), 0)
    813 
    814 
    815 def ContributionMethodDefinitionAddContentTags(builder, contentTags):
    816     builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(contentTags), 0)
    817 
    818 
    819 def ContributionMethodDefinitionStartContentTagsVector(builder, numElems):
    820     return builder.StartVector(4, numElems, 4)
    821 
    822 
    823 def ContributionMethodDefinitionCreateContentTagsVector(builder, data):
    824     return builder.CreateVectorOfTables(data)
    825 
    826 
    827 def ContributionMethodDefinitionAddProgressDescription(builder, progressDescription):
    828     builder.PrependUint32Slot(5, progressDescription, 0)
    829 
    830 
    831 def ContributionMethodDefinitionAddParameters(builder, parameters):
    832     builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(parameters), 0)
    833 
    834 
    835 def ContributionMethodDefinitionStartParametersVector(builder, numElems):
    836     return builder.StartVector(4, numElems, 4)
    837 
    838 
    839 def ContributionMethodDefinitionCreateParametersVector(builder, data):
    840     return builder.CreateVectorOfTables(data)
    841 
    842 
    843 def ContributionMethodDefinitionAddProgressType(builder, progressType):
    844     builder.PrependUint8Slot(7, progressType, 0)
    845 
    846 
    847 def ContributionMethodDefinitionAddProgress(builder, progress):
    848     builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(progress), 0)
    849 
    850 
    851 def ContributionMethodDefinitionAddUiAnnotations(builder, uiAnnotations):
    852     builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(uiAnnotations), 0)
    853 
    854 
    855 def ContributionMethodDefinitionStartUiAnnotationsVector(builder, numElems):
    856     return builder.StartVector(4, numElems, 4)
    857 
    858 
    859 def ContributionMethodDefinitionCreateUiAnnotationsVector(builder, data):
    860     return builder.CreateVectorOfTables(data)
    861 
    862 
    863 def ContributionMethodDefinitionEnd(builder):
    864     return builder.EndObject()
    865 
    866 
    867 class MatcherValues(object):
    868     __slots__ = ['_tab']
    869 
    870     @classmethod
    871     def GetRootAs(cls, buf, offset = 0):
    872         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
    873         x = MatcherValues()
    874         x.Init(buf, n + offset)
    875         return x
    876 
    877     @classmethod
    878     def GetRootAsMatcherValues(cls, buf, offset = 0):
    879         return cls.GetRootAs(buf, offset)
    880 
    881     @classmethod
    882     def MatcherValuesBufferHasIdentifier(cls, buf, offset, size_prefixed = False):
    883         return flatbuffers.util.BufferHasIdentifier(buf, offset, 'ACHV', size_prefixed=size_prefixed)
    884 
    885     def Init(self, buf, pos):
    886         self._tab = flatbuffers.table.Table(buf, pos)
    887 
    888     def ValueType(self):
    889         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
    890         if o != 0:
    891             return self._tab.String(o + self._tab.Pos)
    892 
    893     def Values(self, j):
    894         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    895         if o != 0:
    896             a = self._tab.Vector(o)
    897             return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
    898         return ''
    899 
    900     def ValuesLength(self):
    901         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    902         if o != 0:
    903             return self._tab.VectorLen(o)
    904         return 0
    905 
    906     def ValuesIsNone(self):
    907         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    908         return o == 0
    909 
    910 
    911 def MatcherValuesStart(builder):
    912     builder.StartObject(2)
    913 
    914 
    915 def MatcherValuesAddValueType(builder, valueType):
    916     builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(valueType), 0)
    917 
    918 
    919 def MatcherValuesAddValues(builder, values):
    920     builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(values), 0)
    921 
    922 
    923 def MatcherValuesStartValuesVector(builder, numElems):
    924     return builder.StartVector(4, numElems, 4)
    925 
    926 
    927 def MatcherValuesCreateValuesVector(builder, data):
    928     return builder.CreateVectorOfTables(data)
    929 
    930 
    931 def MatcherValuesEnd(builder):
    932     return builder.EndObject()
    933 
    934 
    935 class ContributionParam(object):
    936     __slots__ = ['_tab']
    937 
    938     @classmethod
    939     def GetRootAs(cls, buf, offset = 0):
    940         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
    941         x = ContributionParam()
    942         x.Init(buf, n + offset)
    943         return x
    944 
    945     @classmethod
    946     def GetRootAsContributionParam(cls, buf, offset = 0):
    947         return cls.GetRootAs(buf, offset)
    948 
    949     @classmethod
    950     def ContributionParamBufferHasIdentifier(cls, buf, offset, size_prefixed = False):
    951         return flatbuffers.util.BufferHasIdentifier(buf, offset, 'ACHV', size_prefixed=size_prefixed)
    952 
    953     def Init(self, buf, pos):
    954         self._tab = flatbuffers.table.Table(buf, pos)
    955 
    956     def Key(self):
    957         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
    958         if o != 0:
    959             return self._tab.String(o + self._tab.Pos)
    960 
    961     def Matchers(self, j):
    962         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    963         if o != 0:
    964             x = self._tab.Vector(o)
    965             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
    966             x = self._tab.Indirect(x)
    967             obj = MatcherValues()
    968             obj.Init(self._tab.Bytes, x)
    969             return obj
    970 
    971     def MatchersLength(self):
    972         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    973         if o != 0:
    974             return self._tab.VectorLen(o)
    975         return 0
    976 
    977     def MatchersIsNone(self):
    978         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    979         return o == 0
    980 
    981 
    982 def ContributionParamStart(builder):
    983     builder.StartObject(2)
    984 
    985 
    986 def ContributionParamAddKey(builder, key):
    987     builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(key), 0)
    988 
    989 
    990 def ContributionParamAddMatchers(builder, matchers):
    991     builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(matchers), 0)
    992 
    993 
    994 def ContributionParamStartMatchersVector(builder, numElems):
    995     return builder.StartVector(4, numElems, 4)
    996 
    997 
    998 def ContributionParamCreateMatchersVector(builder, data):
    999     return builder.CreateVectorOfTables(data)
   1000 
   1001 
   1002 def ContributionParamEnd(builder):
   1003     return builder.EndObject()
   1004 
   1005 
   1006 class ContributionConfig(object):
   1007     __slots__ = ['_tab']
   1008 
   1009     @classmethod
   1010     def GetRootAs(cls, buf, offset = 0):
   1011         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
   1012         x = ContributionConfig()
   1013         x.Init(buf, n + offset)
   1014         return x
   1015 
   1016     @classmethod
   1017     def GetRootAsContributionConfig(cls, buf, offset = 0):
   1018         return cls.GetRootAs(buf, offset)
   1019 
   1020     @classmethod
   1021     def ContributionConfigBufferHasIdentifier(cls, buf, offset, size_prefixed = False):
   1022         return flatbuffers.util.BufferHasIdentifier(buf, offset, 'ACHV', size_prefixed=size_prefixed)
   1023 
   1024     def Init(self, buf, pos):
   1025         self._tab = flatbuffers.table.Table(buf, pos)
   1026 
   1027     def MethodId(self):
   1028         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
   1029         if o != 0:
   1030             return self._tab.String(o + self._tab.Pos)
   1031 
   1032     def Parameters(self, j):
   1033         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
   1034         if o != 0:
   1035             x = self._tab.Vector(o)
   1036             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
   1037             x = self._tab.Indirect(x)
   1038             obj = ContributionParam()
   1039             obj.Init(self._tab.Bytes, x)
   1040             return obj
   1041 
   1042     def ParametersLength(self):
   1043         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
   1044         if o != 0:
   1045             return self._tab.VectorLen(o)
   1046         return 0
   1047 
   1048     def ParametersIsNone(self):
   1049         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
   1050         return o == 0
   1051 
   1052 
   1053 def ContributionConfigStart(builder):
   1054     builder.StartObject(2)
   1055 
   1056 
   1057 def ContributionConfigAddMethodId(builder, methodId):
   1058     builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(methodId), 0)
   1059 
   1060 
   1061 def ContributionConfigAddParameters(builder, parameters):
   1062     builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(parameters), 0)
   1063 
   1064 
   1065 def ContributionConfigStartParametersVector(builder, numElems):
   1066     return builder.StartVector(4, numElems, 4)
   1067 
   1068 
   1069 def ContributionConfigCreateParametersVector(builder, data):
   1070     return builder.CreateVectorOfTables(data)
   1071 
   1072 
   1073 def ContributionConfigEnd(builder):
   1074     return builder.EndObject()
   1075 
   1076 
   1077 class UiAnnotation(object):
   1078     __slots__ = ['_tab']
   1079 
   1080     @classmethod
   1081     def GetRootAs(cls, buf, offset = 0):
   1082         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
   1083         x = UiAnnotation()
   1084         x.Init(buf, n + offset)
   1085         return x
   1086 
   1087     @classmethod
   1088     def GetRootAsUiAnnotation(cls, buf, offset = 0):
   1089         return cls.GetRootAs(buf, offset)
   1090 
   1091     @classmethod
   1092     def UiAnnotationBufferHasIdentifier(cls, buf, offset, size_prefixed = False):
   1093         return flatbuffers.util.BufferHasIdentifier(buf, offset, 'ACHV', size_prefixed=size_prefixed)
   1094 
   1095     def Init(self, buf, pos):
   1096         self._tab = flatbuffers.table.Table(buf, pos)
   1097 
   1098     def Key(self):
   1099         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
   1100         if o != 0:
   1101             return self._tab.String(o + self._tab.Pos)
   1102 
   1103     def Value(self):
   1104         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
   1105         if o != 0:
   1106             return self._tab.String(o + self._tab.Pos)
   1107 
   1108 
   1109 def UiAnnotationStart(builder):
   1110     builder.StartObject(2)
   1111 
   1112 
   1113 def UiAnnotationAddKey(builder, key):
   1114     builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(key), 0)
   1115 
   1116 
   1117 def UiAnnotationAddValue(builder, value):
   1118     builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(value), 0)
   1119 
   1120 
   1121 def UiAnnotationEnd(builder):
   1122     return builder.EndObject()
   1123 
   1124 
   1125 class Achievement(object):
   1126     __slots__ = ['_tab']
   1127 
   1128     @classmethod
   1129     def GetRootAs(cls, buf, offset = 0):
   1130         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
   1131         x = Achievement()
   1132         x.Init(buf, n + offset)
   1133         return x
   1134 
   1135     @classmethod
   1136     def GetRootAsAchievement(cls, buf, offset = 0):
   1137         return cls.GetRootAs(buf, offset)
   1138 
   1139     @classmethod
   1140     def AchievementBufferHasIdentifier(cls, buf, offset, size_prefixed = False):
   1141         return flatbuffers.util.BufferHasIdentifier(buf, offset, 'ACHV', size_prefixed=size_prefixed)
   1142 
   1143     def Init(self, buf, pos):
   1144         self._tab = flatbuffers.table.Table(buf, pos)
   1145 
   1146     def Id(self):
   1147         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
   1148         if o != 0:
   1149             return self._tab.String(o + self._tab.Pos)
   1150 
   1151     def Name(self):
   1152         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
   1153         if o != 0:
   1154             return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
   1155         return 0
   1156 
   1157     def Description(self):
   1158         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
   1159         if o != 0:
   1160             return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
   1161         return 0
   1162 
   1163     def FlavorText(self):
   1164         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
   1165         if o != 0:
   1166             return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
   1167 
   1168     def IconId(self):
   1169         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
   1170         if o != 0:
   1171             return self._tab.String(o + self._tab.Pos)
   1172 
   1173     def IssuerNpcCorp(self):
   1174         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
   1175         if o != 0:
   1176             return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
   1177 
   1178     def Contribution(self):
   1179         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
   1180         if o != 0:
   1181             x = self._tab.Indirect(o + self._tab.Pos)
   1182             obj = ContributionConfig()
   1183             obj.Init(self._tab.Bytes, x)
   1184             return obj
   1185 
   1186     def Milestones(self, j):
   1187         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
   1188         if o != 0:
   1189             x = self._tab.Vector(o)
   1190             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
   1191             x = self._tab.Indirect(x)
   1192             obj = AchievementMilestone()
   1193             obj.Init(self._tab.Bytes, x)
   1194             return obj
   1195 
   1196     def MilestonesLength(self):
   1197         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
   1198         if o != 0:
   1199             return self._tab.VectorLen(o)
   1200         return 0
   1201 
   1202     def MilestonesIsNone(self):
   1203         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
   1204         return o == 0
   1205 
   1206     def ReleaseDateUnixMs(self):
   1207         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
   1208         if o != 0:
   1209             return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
   1210 
   1211     def ExpirationDateUnixMs(self):
   1212         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
   1213         if o != 0:
   1214             return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
   1215 
   1216     def UiAnnotations(self, j):
   1217         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
   1218         if o != 0:
   1219             x = self._tab.Vector(o)
   1220             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
   1221             x = self._tab.Indirect(x)
   1222             obj = UiAnnotation()
   1223             obj.Init(self._tab.Bytes, x)
   1224             return obj
   1225 
   1226     def UiAnnotationsLength(self):
   1227         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
   1228         if o != 0:
   1229             return self._tab.VectorLen(o)
   1230         return 0
   1231 
   1232     def UiAnnotationsIsNone(self):
   1233         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
   1234         return o == 0
   1235 
   1236     def Tags(self, j):
   1237         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
   1238         if o != 0:
   1239             a = self._tab.Vector(o)
   1240             return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
   1241         return ''
   1242 
   1243     def TagsLength(self):
   1244         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
   1245         if o != 0:
   1246             return self._tab.VectorLen(o)
   1247         return 0
   1248 
   1249     def TagsIsNone(self):
   1250         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
   1251         return o == 0
   1252 
   1253     def Archived(self):
   1254         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
   1255         if o != 0:
   1256             return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
   1257         return False
   1258 
   1259     def InternalName(self):
   1260         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
   1261         if o != 0:
   1262             return self._tab.String(o + self._tab.Pos)
   1263 
   1264 
   1265 def AchievementStart(builder):
   1266     builder.StartObject(14)
   1267 
   1268 
   1269 def AchievementAddId(builder, id):
   1270     builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(id), 0)
   1271 
   1272 
   1273 def AchievementAddName(builder, name):
   1274     builder.PrependUint32Slot(1, name, 0)
   1275 
   1276 
   1277 def AchievementAddDescription(builder, description):
   1278     builder.PrependUint32Slot(2, description, 0)
   1279 
   1280 
   1281 def AchievementAddFlavorText(builder, flavorText):
   1282     builder.PrependUint32Slot(3, flavorText, None)
   1283 
   1284 
   1285 def AchievementAddIconId(builder, iconId):
   1286     builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(iconId), 0)
   1287 
   1288 
   1289 def AchievementAddIssuerNpcCorp(builder, issuerNpcCorp):
   1290     builder.PrependInt32Slot(5, issuerNpcCorp, None)
   1291 
   1292 
   1293 def AchievementAddContribution(builder, contribution):
   1294     builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(contribution), 0)
   1295 
   1296 
   1297 def AchievementAddMilestones(builder, milestones):
   1298     builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(milestones), 0)
   1299 
   1300 
   1301 def AchievementStartMilestonesVector(builder, numElems):
   1302     return builder.StartVector(4, numElems, 4)
   1303 
   1304 
   1305 def AchievementCreateMilestonesVector(builder, data):
   1306     return builder.CreateVectorOfTables(data)
   1307 
   1308 
   1309 def AchievementAddReleaseDateUnixMs(builder, releaseDateUnixMs):
   1310     builder.PrependInt64Slot(8, releaseDateUnixMs, None)
   1311 
   1312 
   1313 def AchievementAddExpirationDateUnixMs(builder, expirationDateUnixMs):
   1314     builder.PrependInt64Slot(9, expirationDateUnixMs, None)
   1315 
   1316 
   1317 def AchievementAddUiAnnotations(builder, uiAnnotations):
   1318     builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(uiAnnotations), 0)
   1319 
   1320 
   1321 def AchievementStartUiAnnotationsVector(builder, numElems):
   1322     return builder.StartVector(4, numElems, 4)
   1323 
   1324 
   1325 def AchievementCreateUiAnnotationsVector(builder, data):
   1326     return builder.CreateVectorOfTables(data)
   1327 
   1328 
   1329 def AchievementAddTags(builder, tags):
   1330     builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(tags), 0)
   1331 
   1332 
   1333 def AchievementStartTagsVector(builder, numElems):
   1334     return builder.StartVector(4, numElems, 4)
   1335 
   1336 
   1337 def AchievementCreateTagsVector(builder, data):
   1338     return builder.CreateVectorOfTables(data)
   1339 
   1340 
   1341 def AchievementAddArchived(builder, archived):
   1342     builder.PrependBoolSlot(12, archived, 0)
   1343 
   1344 
   1345 def AchievementAddInternalName(builder, internalName):
   1346     builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(internalName), 0)
   1347 
   1348 
   1349 def AchievementEnd(builder):
   1350     return builder.EndObject()
   1351 
   1352 
   1353 class Category(object):
   1354     __slots__ = ['_tab']
   1355 
   1356     @classmethod
   1357     def GetRootAs(cls, buf, offset = 0):
   1358         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
   1359         x = Category()
   1360         x.Init(buf, n + offset)
   1361         return x
   1362 
   1363     @classmethod
   1364     def GetRootAsCategory(cls, buf, offset = 0):
   1365         return cls.GetRootAs(buf, offset)
   1366 
   1367     @classmethod
   1368     def CategoryBufferHasIdentifier(cls, buf, offset, size_prefixed = False):
   1369         return flatbuffers.util.BufferHasIdentifier(buf, offset, 'ACHV', size_prefixed=size_prefixed)
   1370 
   1371     def Init(self, buf, pos):
   1372         self._tab = flatbuffers.table.Table(buf, pos)
   1373 
   1374     def Id(self):
   1375         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
   1376         if o != 0:
   1377             return self._tab.String(o + self._tab.Pos)
   1378 
   1379     def Name(self):
   1380         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
   1381         if o != 0:
   1382             return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
   1383         return 0
   1384 
   1385     def Description(self):
   1386         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
   1387         if o != 0:
   1388             return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
   1389         return 0
   1390 
   1391     def IconId(self):
   1392         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
   1393         if o != 0:
   1394             return self._tab.String(o + self._tab.Pos)
   1395 
   1396     def Milestones(self, j):
   1397         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
   1398         if o != 0:
   1399             x = self._tab.Vector(o)
   1400             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
   1401             x = self._tab.Indirect(x)
   1402             obj = CategoryMilestone()
   1403             obj.Init(self._tab.Bytes, x)
   1404             return obj
   1405 
   1406     def MilestonesLength(self):
   1407         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
   1408         if o != 0:
   1409             return self._tab.VectorLen(o)
   1410         return 0
   1411 
   1412     def MilestonesIsNone(self):
   1413         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
   1414         return o == 0
   1415 
   1416     def Categories(self, j):
   1417         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
   1418         if o != 0:
   1419             x = self._tab.Vector(o)
   1420             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
   1421             x = self._tab.Indirect(x)
   1422             obj = Category()
   1423             obj.Init(self._tab.Bytes, x)
   1424             return obj
   1425 
   1426     def CategoriesLength(self):
   1427         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
   1428         if o != 0:
   1429             return self._tab.VectorLen(o)
   1430         return 0
   1431 
   1432     def CategoriesIsNone(self):
   1433         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
   1434         return o == 0
   1435 
   1436     def Achievements(self, j):
   1437         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
   1438         if o != 0:
   1439             x = self._tab.Vector(o)
   1440             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
   1441             x = self._tab.Indirect(x)
   1442             obj = Achievement()
   1443             obj.Init(self._tab.Bytes, x)
   1444             return obj
   1445 
   1446     def AchievementsLength(self):
   1447         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
   1448         if o != 0:
   1449             return self._tab.VectorLen(o)
   1450         return 0
   1451 
   1452     def AchievementsIsNone(self):
   1453         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
   1454         return o == 0
   1455 
   1456     def InternalName(self):
   1457         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
   1458         if o != 0:
   1459             return self._tab.String(o + self._tab.Pos)
   1460 
   1461     def UiAnnotations(self, j):
   1462         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
   1463         if o != 0:
   1464             x = self._tab.Vector(o)
   1465             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
   1466             x = self._tab.Indirect(x)
   1467             obj = UiAnnotation()
   1468             obj.Init(self._tab.Bytes, x)
   1469             return obj
   1470 
   1471     def UiAnnotationsLength(self):
   1472         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
   1473         if o != 0:
   1474             return self._tab.VectorLen(o)
   1475         return 0
   1476 
   1477     def UiAnnotationsIsNone(self):
   1478         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
   1479         return o == 0
   1480 
   1481 
   1482 def CategoryStart(builder):
   1483     builder.StartObject(9)
   1484 
   1485 
   1486 def CategoryAddId(builder, id):
   1487     builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(id), 0)
   1488 
   1489 
   1490 def CategoryAddName(builder, name):
   1491     builder.PrependUint32Slot(1, name, 0)
   1492 
   1493 
   1494 def CategoryAddDescription(builder, description):
   1495     builder.PrependUint32Slot(2, description, 0)
   1496 
   1497 
   1498 def CategoryAddIconId(builder, iconId):
   1499     builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(iconId), 0)
   1500 
   1501 
   1502 def CategoryAddMilestones(builder, milestones):
   1503     builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(milestones), 0)
   1504 
   1505 
   1506 def CategoryStartMilestonesVector(builder, numElems):
   1507     return builder.StartVector(4, numElems, 4)
   1508 
   1509 
   1510 def CategoryCreateMilestonesVector(builder, data):
   1511     return builder.CreateVectorOfTables(data)
   1512 
   1513 
   1514 def CategoryAddCategories(builder, categories):
   1515     builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(categories), 0)
   1516 
   1517 
   1518 def CategoryStartCategoriesVector(builder, numElems):
   1519     return builder.StartVector(4, numElems, 4)
   1520 
   1521 
   1522 def CategoryCreateCategoriesVector(builder, data):
   1523     return builder.CreateVectorOfTables(data)
   1524 
   1525 
   1526 def CategoryAddAchievements(builder, achievements):
   1527     builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(achievements), 0)
   1528 
   1529 
   1530 def CategoryStartAchievementsVector(builder, numElems):
   1531     return builder.StartVector(4, numElems, 4)
   1532 
   1533 
   1534 def CategoryCreateAchievementsVector(builder, data):
   1535     return builder.CreateVectorOfTables(data)
   1536 
   1537 
   1538 def CategoryAddInternalName(builder, internalName):
   1539     builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(internalName), 0)
   1540 
   1541 
   1542 def CategoryAddUiAnnotations(builder, uiAnnotations):
   1543     builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(uiAnnotations), 0)
   1544 
   1545 
   1546 def CategoryStartUiAnnotationsVector(builder, numElems):
   1547     return builder.StartVector(4, numElems, 4)
   1548 
   1549 
   1550 def CategoryCreateUiAnnotationsVector(builder, data):
   1551     return builder.CreateVectorOfTables(data)
   1552 
   1553 
   1554 def CategoryEnd(builder):
   1555     return builder.EndObject()
   1556 
   1557 
   1558 class AchievementData(object):
   1559     __slots__ = ['_tab']
   1560 
   1561     @classmethod
   1562     def GetRootAs(cls, buf, offset = 0):
   1563         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
   1564         x = AchievementData()
   1565         x.Init(buf, n + offset)
   1566         return x
   1567 
   1568     @classmethod
   1569     def GetRootAsAchievementData(cls, buf, offset = 0):
   1570         return cls.GetRootAs(buf, offset)
   1571 
   1572     @classmethod
   1573     def AchievementDataBufferHasIdentifier(cls, buf, offset, size_prefixed = False):
   1574         return flatbuffers.util.BufferHasIdentifier(buf, offset, 'ACHV', size_prefixed=size_prefixed)
   1575 
   1576     def Init(self, buf, pos):
   1577         self._tab = flatbuffers.table.Table(buf, pos)
   1578 
   1579     def Goals(self):
   1580         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
   1581         if o != 0:
   1582             x = self._tab.Indirect(o + self._tab.Pos)
   1583             obj = Category()
   1584             obj.Init(self._tab.Bytes, x)
   1585             return obj
   1586 
   1587     def Challenges(self):
   1588         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
   1589         if o != 0:
   1590             x = self._tab.Indirect(o + self._tab.Pos)
   1591             obj = Category()
   1592             obj.Init(self._tab.Bytes, x)
   1593             return obj
   1594 
   1595     def TimeLimited(self):
   1596         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
   1597         if o != 0:
   1598             x = self._tab.Indirect(o + self._tab.Pos)
   1599             obj = Category()
   1600             obj.Init(self._tab.Bytes, x)
   1601             return obj
   1602 
   1603     def ContributionMethods(self, j):
   1604         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
   1605         if o != 0:
   1606             x = self._tab.Vector(o)
   1607             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
   1608             x = self._tab.Indirect(x)
   1609             obj = ContributionMethodDefinition()
   1610             obj.Init(self._tab.Bytes, x)
   1611             return obj
   1612 
   1613     def ContributionMethodsLength(self):
   1614         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
   1615         if o != 0:
   1616             return self._tab.VectorLen(o)
   1617         return 0
   1618 
   1619     def ContributionMethodsIsNone(self):
   1620         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
   1621         return o == 0
   1622 
   1623 
   1624 def AchievementDataStart(builder):
   1625     builder.StartObject(4)
   1626 
   1627 
   1628 def AchievementDataAddGoals(builder, goals):
   1629     builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(goals), 0)
   1630 
   1631 
   1632 def AchievementDataAddChallenges(builder, challenges):
   1633     builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(challenges), 0)
   1634 
   1635 
   1636 def AchievementDataAddTimeLimited(builder, timeLimited):
   1637     builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(timeLimited), 0)
   1638 
   1639 
   1640 def AchievementDataAddContributionMethods(builder, contributionMethods):
   1641     builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(contributionMethods), 0)
   1642 
   1643 
   1644 def AchievementDataStartContributionMethodsVector(builder, numElems):
   1645     return builder.StartVector(4, numElems, 4)
   1646 
   1647 
   1648 def AchievementDataCreateContributionMethodsVector(builder, data):
   1649     return builder.CreateVectorOfTables(data)
   1650 
   1651 
   1652 def AchievementDataEnd(builder):
   1653     return builder.EndObject()
	NovaBryan/EVE_Dump
	Log \| Files \| 📦 下载最新源码 (.zip) \| Refs \| README