diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..1101c87 --- /dev/null +++ b/.gitignore @@ -0,0 +1,13 @@ +/.vscode +*.pyc +logs/latest.log +*.rs +/build +__pycache__/ +.env +/resources +*.proto +*.txt +/proto +.idea/ +/logs diff --git a/database/account/account_data.py b/database/account/account_data.py new file mode 100644 index 0000000..7e08538 --- /dev/null +++ b/database/account/account_data.py @@ -0,0 +1,39 @@ +from database.mongodb import get_collection +from typing import Optional +from pydantic import BaseModel +from utils.crypto import generate_combo_token + +class AccountModel(BaseModel): + id: int + username: str + token: str + +account_collection = get_collection("accounts") + +def find_account_by_uid(uid: int) -> Optional[AccountModel]: + account_data = account_collection.find_one({"_id": uid}) + if account_data: + account_data["id"] = int(account_data["_id"]) + del account_data["_id"] + return AccountModel(**account_data) + return None + +def find_account_by_name(name: str) -> Optional[AccountModel]: + account_data = account_collection.find_one({"username": name}) + if account_data: + account_data["id"] = int(account_data["_id"]) + del account_data["_id"] + return AccountModel(**account_data) + return None + +def create_new_account(username: str) -> AccountModel: + last_account = account_collection.find_one(sort=[("_id", -1)]) + uid = (last_account["_id"] + 1) if last_account else 1001 + token = generate_combo_token(str(uid)) + new_account = { + "_id": uid, + "username": username, + "token": token + } + account_collection.insert_one(new_account) + return AccountModel(id=uid, username=username, token=new_account["token"]) diff --git a/database/avatar/avatar_data.py b/database/avatar/avatar_data.py new file mode 100644 index 0000000..f83d262 --- /dev/null +++ b/database/avatar/avatar_data.py @@ -0,0 +1,142 @@ +from database.mongodb import get_collection +from typing import Optional +from database.base_database_data import BaseDatabaseData +from game_server.resource import ResourceManager +from game_server.resource.configdb.avatar_config import AvatarConfig +from typing import List +from rail_proto.lib import ( + Avatar, + AvatarSkillTree, + BattleAvatar, + AvatarType, + SpBarInfo, + AvatarSkillTree, + BattleEquipment, + EquipRelic +) + +avatars_collection = get_collection("avatars") + +class AvatarData(BaseDatabaseData): + avatar_id: int + level: int = 80 + exp: int = 0 + promotion: int = 6 + rank: int = 6 + lightcone_id: int = 0 + relic_ids: dict[str,int] = {} + skills: dict[str,int] = {} + current_hp: int = 10000 + current_sp: int = 0 + + def add_avatar(self) -> "AvatarData": + get_avatar = avatars_collection.find_one({"uid": self.uid, "avatar_id":self.avatar_id}) + if get_avatar: + return False + + avatar = ResourceManager.instance().find_by_index(AvatarConfig, self.avatar_id) + if not avatar: + return False + + self.avatar_id=avatar.AvatarID + + for skill_id,skill_level in avatar.AvatarSkills.items(): + self.skills[str(skill_id)] = skill_level + + avatar_data = self.model_dump() + avatars_collection.insert_one(avatar_data) + return self + + def ToProto(self) -> Avatar: + return Avatar( + base_avatar_id=self.avatar_id, + level=self.level, + exp=self.exp, + promotion=self.promotion, + rank=self.rank, + skilltree_list=[ + AvatarSkillTree( + point_id=int(skill_id), + level=skill_level + ) + for skill_id,skill_level in self.skills.items() + ], + equipment_unique_id=self.lightcone_id, + equip_relic_list=[ + EquipRelic( + relic_unique_id=relic_id, + type=int(type) + ) + for type,relic_id in self.relic_ids.items() + ], + has_taken_promotion_reward_list=[1,2,3,4,5,6], + ) + + def ToBattleProto(self,index,session): + get_equipment = None + if self.lightcone_id > 0: + get_equipment = session.player.inventory_manager.get(self.lightcone_id) + + return BattleAvatar( + id=self.avatar_id, + index=index, + level=self.level, + promotion=self.promotion, + rank=self.rank, + hp=self.current_hp, + avatar_type=AvatarType.AVATAR_FORMAL_TYPE.value, + sp_bar=SpBarInfo( + cur_sp=5000, + max_sp=10000 + ), + skilltree_list=[ + AvatarSkillTree( + point_id=int(skill_id), + level=level + ) + for skill_id,level in self.skills.items() + ], + equipment_list=[ + BattleEquipment( + id=get_equipment.item_id if get_equipment else 0, + level=get_equipment.level if get_equipment else 0, + promotion=get_equipment.promotion if get_equipment else 0, + rank=get_equipment.rank if get_equipment else 0 + ) + ], + relic_list = [ + session.player.inventory_manager.get(relic_id).RelicBattleProto() + for type, relic_id in self.relic_ids.items() + if relic_id > 0 + ] + ) + + def save_avatar(self): + avatar_data = self.model_dump() + avatar_data["uid"] = self.uid + query = {"uid": self.uid, "avatar_id": self.avatar_id} + avatars_collection.update_one(query, {"$set": avatar_data}) + + +def find_avatar_by_avatar_id(uid: int, avatar_id: int) -> Optional[AvatarData]: + avatar_data = avatars_collection.find_one({"uid": uid, "avatar_id":avatar_id}) + if avatar_data: + del avatar_data["_id"] + return AvatarData(**avatar_data) + return None + +def get_all_avatars_by_uid(uid: int) -> List[AvatarData]: + avatars_data = avatars_collection.find({"uid": uid}) + result = [] + for avatar in avatars_data: + del avatar["_id"] + result.append(AvatarData(**avatar)) + return result + + + + + + + + diff --git a/database/base_database_data.py b/database/base_database_data.py new file mode 100644 index 0000000..cd46b20 --- /dev/null +++ b/database/base_database_data.py @@ -0,0 +1,4 @@ +from pydantic import BaseModel + +class BaseDatabaseData(BaseModel): + uid: int = 0 \ No newline at end of file diff --git a/database/inventory/inventory_data.py b/database/inventory/inventory_data.py new file mode 100644 index 0000000..69f4007 --- /dev/null +++ b/database/inventory/inventory_data.py @@ -0,0 +1,159 @@ +from database.mongodb import get_collection +from database.base_database_data import BaseDatabaseData +from game_server.resource import ResourceManager +from game_server.resource.configdb.relic_main_affix_config import RelicMainAffixConfigData +from game_server.resource.configdb.equipment_config import EquipmentConfig +from game_server.resource.configdb.relic_config import RelicConfigData +from game_server.game.items.relic_manager import RelicManager +from game_server.game.enums.avatar.relic_type import RelicTypeEnum +from typing import List +from pydantic import BaseModel +from rail_proto.lib import ( + Equipment, + Relic, + RelicAffix, + BattleRelic, + RelicAffix +) + +items_collection = get_collection("items") + +class SubAffix(BaseModel): + id: int + count: int + step: int + +class InventoryData(BaseDatabaseData): + item_id: int + count: int = 1 + level: int = 1 + exp: int = 0 + promotion: int = 0 + rank: int = 0 + locked: bool = False + discarded: bool = False + main_affix: int = 0 + sub_affix: list[SubAffix] = [] + equip_avatar: int = 0 + unique_id: int = 0 + main_type: int = 0 + sub_type: int = 0 + + def add_lightcone(self): + last_item = items_collection.find_one({"uid": self.uid},sort=[("unique_id", -1)]) + unique_id = last_item["unique_id"] + 1 if last_item else 1 + equipment = ResourceManager.instance().find_by_index(EquipmentConfig, self.item_id) + if not equipment: + return None + + self.level = 80 + self.promotion = 6 + self.main_type = 1 + self.unique_id = unique_id + + lightcone_data = self.model_dump() + items_collection.insert_one(lightcone_data) + return self + + def add_relic(self): + last_item = items_collection.find_one({"uid": self.uid}, sort=[("unique_id", -1)]) + unique_id = last_item["unique_id"] + 1 if last_item else 1 + + relic = ResourceManager.instance().find_by_index(RelicConfigData, self.item_id) + if not relic: + return None + + self.level = 15 + self.main_type = 2 + self.sub_type = RelicTypeEnum[relic.Type].value + + relic_manager = RelicManager() + main_stat = "" + get_main_affix = None + + if self.main_affix > 0: + relics = ResourceManager.instance().find_by_index(RelicConfigData, self.item_id) + main_affix_group = ResourceManager.instance().find_all_by_index(RelicMainAffixConfigData, relics.MainAffixGroup) + main_stat = next( + (affix.Property for affix in main_affix_group if affix.AffixID == int(self.main_affix)) + ) + elif self.main_affix == 0: + get_main_affix = relic_manager.GetRandomRelicMainAffix(self.item_id) + self.main_affix = get_main_affix.AffixID + + if not main_stat and get_main_affix: + main_stat = get_main_affix.Property + + if not self.sub_affix: + self.sub_affix = relic_manager.GetRandomRelicSubAffix(self.item_id, main_stat, 4) + + if self.sub_affix and len(self.sub_affix) < 4: + self.sub_affix.extend(relic_manager.GetRandomRelicSubAffix(self.item_id, main_stat, 4 - len(self.sub_affix), self.sub_affix)) + + self.unique_id = unique_id + + relic_data = self.model_dump() + items_collection.insert_one(relic_data) + + return self + + def ToProto(self): + if self.main_type == 1: + proto = Equipment( + tid=self.item_id, + level=self.level, + rank=self.rank, + promotion=self.promotion, + dress_avatar_id=self.equip_avatar, + unique_id=self.unique_id, + ) + if self.main_type == 2: + proto = Relic( + tid=self.item_id, + level=self.level, + dress_avatar_id=self.equip_avatar, + unique_id=self.unique_id, + main_affix_id=self.main_affix, + sub_affix_list=[ + RelicAffix( + affix_id=affix.id, + cnt=affix.count, + step=affix.step + ) + for affix in self.sub_affix + ] + ) + return proto + + def save_item(self): + item_data = self.model_dump() + item_data["uid"] = self.uid + query = {"uid": self.uid, "unique_id": self.unique_id} + items_collection.update_one(query, {"$set": item_data}) + + def RelicBattleProto(self): + return BattleRelic( + id=self.item_id, + level=self.level, + main_affix_id=self.main_affix, + sub_affix_list=[ + RelicAffix( + affix_id=affix.id, + cnt=affix.count, + step=affix.step + ) + for affix in self.sub_affix + ], + unique_id=self.unique_id, + type=self.sub_type + ) + + + +def get_all_items_by_uid(uid: int) -> List[InventoryData]: + items_data = items_collection.find({"uid": uid}) + result = [] + for items in items_data: + del items["_id"] + result.append(InventoryData(**items)) + return result \ No newline at end of file diff --git a/database/lineup/lineup_data.py b/database/lineup/lineup_data.py new file mode 100644 index 0000000..fe03925 --- /dev/null +++ b/database/lineup/lineup_data.py @@ -0,0 +1,67 @@ +from database.mongodb import get_collection +from database.base_database_data import BaseDatabaseData +from typing import List +from rail_proto.lib import ( + LineupInfo, + ExtraLineupType, + LineupAvatar, + SpBarInfo, + AvatarType +) + +lineups_collection = get_collection("lineups") + +class LineupData(BaseDatabaseData): + name: str = "" + index: int = 0 + mp: int = 5 + extra_lineup: ExtraLineupType = ExtraLineupType.LINEUP_NONE + leader_slot: int = 0 + avatar_list: list[int] = [] + + def ToProto(self) -> LineupInfo: + return LineupInfo( + name=self.name, + index=self.index, + mp=self.mp, + max_mp=5, + extra_lineup_type=self.extra_lineup, + leader_slot=self.leader_slot, + avatar_list=[ + LineupAvatar( + id=avatar_id, + slot=index, + hp=10000, + sp_bar=SpBarInfo(cur_sp=5000, max_sp=10000), + satiety=100, + avatar_type=AvatarType.AVATAR_FORMAL_TYPE.value + ) + for index, avatar_id in enumerate(self.avatar_list) + ] + ) + def add_lineup(self): + lineup_data = self.model_dump() + lineups_collection.insert_one(lineup_data) + return self + + def save_lineup(self): + lineup_data = self.model_dump() + lineup_data["uid"] = self.uid + query = {"uid": self.uid, "index": self.index} + existing_lineup = lineups_collection.find_one(query) + + if existing_lineup: + lineups_collection.update_one(query, {"$set": lineup_data}) + else: + lineups_collection.insert_one(lineup_data) + + return True + + +def get_all_lineup_by_uid(uid: int) -> List[LineupData]: + lineups_data = lineups_collection.find({"uid": uid}) + result = [] + for lineup in lineups_data: + del lineup["_id"] + result.append(LineupData(**lineup)) + return result \ No newline at end of file diff --git a/database/mongodb.py b/database/mongodb.py new file mode 100644 index 0000000..60ef9a3 --- /dev/null +++ b/database/mongodb.py @@ -0,0 +1,10 @@ +from pymongo import MongoClient + +client = MongoClient("mongodb://localhost:27017") + +def get_database(): + return client["neonsr"] + +def get_collection(collection_name: str): + database = client["neonsr"] + return database[collection_name] diff --git a/database/player/player_data.py b/database/player/player_data.py new file mode 100644 index 0000000..c2c807c --- /dev/null +++ b/database/player/player_data.py @@ -0,0 +1,103 @@ +from database.mongodb import get_collection +from typing import Optional +from pydantic import BaseModel +from database.base_database_data import BaseDatabaseData +from rail_proto.lib import ( + Gender, + PlayerBasicInfo, + PlayerDetailInfo, + PlatformType, + PlayerRecordInfo +) + +players_collection = get_collection("players") + +class PositionModel(BaseModel): + x: int + y: int + z: int + +class RotationModel(BaseModel): + x: int + y: int + z: int + +class PlayerData(BaseDatabaseData): + name: str = "" + signature: str = "" + birthday: int = 0 + cur_basic_type: int = 8001 + head_icon: int = 208001 + phone_theme: int = 221000 + chat_bubble: int = 220000 + current_bgm: int = 210007 + current_gender: Gender = Gender.GenderMan + level: int = 70 + exp: int = 0 + world_level: int = 0 + scoin: int = 0 # Credits + hcoin: int = 0 # Jade + mcoin: int = 0 # Crystals + plane_id: int = 10000 + floor_id: int = 10000000 + entry_id: int = 100000104 + cur_lineup: int = 0 + pos: Optional[PositionModel] = PositionModel(x=0,y=0,z=0) + rot: Optional[RotationModel] = RotationModel(x=0,y=0,z=0) + + def ToProto(self) -> PlayerBasicInfo: + return PlayerBasicInfo( + nickname=self.name, + level=self.level, + exp=self.exp, + world_level=self.world_level, + scoin=self.scoin, + hcoin=self.hcoin, + mcoin=self.mcoin, + stamina=240 + ) + + def ToDetailProto(self) -> PlayerDetailInfo: + return PlayerDetailInfo( + nickname=self.Name, + level=self.Level, + signature=self.Signature, + is_banned=False, + head_icon=self.HeadIcon, + platform=PlatformType.PC, + uid=self.uid, + world_level=self.WorldLevel, + record_info=PlayerRecordInfo() + ) + + def create_player_data(self,name : str): + try: + self.name = name + player_data = self.model_dump() + players_collection.insert_one(player_data) + return PlayerData(**player_data) + except Exception as e: + print(f"Error creating player data: {e}") + return None + + def save_player_data(self): + try: + player_data = self.model_dump() + player_data["uid"] = self.uid + query = {"uid": self.uid} + players_collection.update_one(query, {"$set": player_data}) + return True + except Exception as e: + print(f"Error menyimpan data pemain: {e}") + return False + + +def find_player_by_uid(uid: int) -> Optional[PlayerData]: + player_data = players_collection.find_one({"uid": uid}) + if player_data: + del player_data["_id"] + return PlayerData(**player_data) + return None + + + diff --git a/game_server/dummy.py b/game_server/dummy.py new file mode 100644 index 0000000..6eef586 --- /dev/null +++ b/game_server/dummy.py @@ -0,0 +1,123 @@ +dummyprotolist = [ + "SceneEntityMove", + "GetMissionData", + "FinishTalkMission", + "InteractProp", + + "GetFirstTalkNpc", + "GetAssistHistory", + "GetTrackPhotoActivityData", + "GetSwordTrainingData", + "GetSummonActivityData", + "GetMainMissionCustomValue" + "SetPlayerInfo", + "GetPlayerDetailInfo", + "GetLevelRewardTakenList", + "GetRogueScoreRewardInfo", + "GetGachaInfo", + "QueryProductInfo", + "GetQuestData", + "GetQuestRecord", + "GetFriendApplyListInfo", + "GetCurAssist", + "GetRogueHandbookData", + "GetDailyActiveInfo", + "GetFightActivityData", + "GetMultipleDropInfo", + "GetPlayerReturnMultiDropInfo", + "GetShareData", + "GetTreasureDungeonActivityData", + "PlayerReturnInfoQuery", + "GetActivityScheduleConfig", + + + "GetMissionEventData", + "GetRogueInfo", + "GetExpeditionData", + "GetRogueDialogueEventData", + "GetJukeboxData", + "SyncClientResVersion", + "DailyFirstMeetPam", + "GetMuseumInfo", + "GetLoginActivity", + "GetRaidInfo", + "GetTrialActivityData", + "GetBoxingClubInfo", + "GetNpcStatus", + "TextJoinQuery", + "GetSpringRecoverData", + "GetChatFriendHistory", + "GetSecretKeyInfo", + "GetVideoVersionKey", + "GetCurBattleInfo", + + "GetMarkItemList", + "RogueTournGetCurRogueCocoonInfo", + "GetAllServerPrefsData", + "GetRogueCommonDialogueData", + "GetRogueEndlessActivityData", + "RogueArcadeGetInfo", + "ChessRogueQuery", + "RogueTournQuery", + "RogueMagicQuery", + "GetBattleCollegeData", + "GetHeartDialInfo", + "TrainPartyGetData", + "HeliobusActivityData", + "GetEnteredScene", + "GetAetherDivideInfo", + "GetMapRotationData", + "GetRogueCollection", + "GetRogueExhibition", + "GetPetData", + "EnterSection", + + + "GetMultiPathAvatarInfo", + "GetCurChallenge", + "GetMissionMessageInfo", + "SwitchHandData", + "GetPamSkinData", + "GetMainMissionCustomValue", + "GetNpcMessageGroup", + "GetRechargeGiftInfo", + "GetFriendLoginInfo", + "GetChessRogueNousStoryInfo", + "CommonRogueQuery", + "GetStarFightData", + "EvolveBuildQueryInfo", + "GetAlleyInfo", + "GetAetherDivideChallengeInfo", + "GetStrongChallengeActivityData", + "GetOfferingInfo", + "ClockParkGetInfo", + "MusicRhythmData", + "GetGunPlayData", + "GetFightFestData", + "DifficultyAdjustmentGetData", + "ChimeraGetData", + "MarbleGetData", + "GetRechargeBenefitInfo", + "ParkourGetData", + "SpaceZooData", + "GetMaterialSubmitActivityData", + "GetPreAvatarList", + "TravelBrochureGetData", + "RaidCollectionData", + "GetChatEmojiList", + "GetTelevisionActivityData", + "GetTrainVisitorRegister", + "GetLoginChatInfo", + "GetFeverTimeActivityData", + "TarotBookGetData", + "GetMarkChest", + "GetArchiveData", + "GetAllSaveRaid", + "MatchThreeGetData", + "GetDrinkMakerData", + "UpdateServerPrefsData", + "UpdateTrackMainMissionId", + "GetMail", + "GetShopList", + "PlayerLogout", +] \ No newline at end of file diff --git a/game_server/game/avatar/avatar_manager.py b/game_server/game/avatar/avatar_manager.py new file mode 100644 index 0000000..36a1e5b --- /dev/null +++ b/game_server/game/avatar/avatar_manager.py @@ -0,0 +1,13 @@ +import dataclasses +from rail_proto.lib import AvatarSkillTree,EquipRelic + +@dataclasses.dataclass +class AvatarManager: + avatar_id: int + level: int + exp: int + promotion: int + rank: int + skills: list[AvatarSkillTree] + equip_id: int = 0 + relic_list: dict[int,EquipRelic] = dataclasses.field(default_factory=dict) \ No newline at end of file diff --git a/game_server/game/chat/command/__init__.py b/game_server/game/chat/command/__init__.py new file mode 100644 index 0000000..f509ebf --- /dev/null +++ b/game_server/game/chat/command/__init__.py @@ -0,0 +1,16 @@ +import importlib +import os +import sys + + +folder = "game_server/game/chat/command" +sys.path.append(os.path.dirname(folder)) + +for filename in os.listdir(folder): + if filename.endswith(".py") and filename != "__init__.py": + module_name = filename[:-3] + module_path = f"game_server.game.chat.command.{module_name}" + try: + importlib.import_module(module_path) + except Exception as e: + print(f"Error importing module '{module_path}': {e}") diff --git a/game_server/game/chat/command/give.py b/game_server/game/chat/command/give.py new file mode 100644 index 0000000..2665892 --- /dev/null +++ b/game_server/game/chat/command/give.py @@ -0,0 +1,60 @@ +from game_server.game.chat.decorators import Command +from game_server.net.session import PlayerSession +from game_server.resource import ResourceManager +from game_server.resource.configdb.equipment_config import EquipmentConfig +from game_server.resource.configdb.relic_config import RelicConfigData +from game_server.resource.configdb.relic_main_affix_config import RelicMainAffixConfigData +from game_server.resource.configdb.relic_sub_affix_config import RelicSubAffixConfigData +from database.inventory.inventory_data import SubAffix + +@Command( + prefix="give", + usage="/give", +) +async def execute(session:PlayerSession, item_id, param1=None, param2=None, param3=None, param4=None, param5=None): + try: + sync = False + lightcones = ResourceManager.instance().find_by_index(EquipmentConfig,item_id) + relics = ResourceManager.instance().find_by_index(RelicConfigData,item_id) + + if lightcones: + rank = 1 + if param1 and param1.startswith("r") and len(param1) == 2: + rank_value = param1[1] + if rank_value.isdigit() and 1 <= int(rank_value) <= 5: + rank = int(rank_value) + elif rank_value.isdigit() and int(rank_value) > 5: + rank = 5 + item = session.player.add_lightcone(item_id, rank) + if item: + session.player.inventory_manager[item.unique_id] = item + sync = True + elif relics: + main_stat = 0 + main_property = "" + main_affix_group = ResourceManager.instance().find_all_by_index(RelicMainAffixConfigData, relics.MainAffixGroup) + sub_affix_list = [] + + if param1 and param1.startswith("s") and len(param1) == 2 and param1[1].isdigit(): + main_affix = next((affix for affix in main_affix_group if affix.AffixID == int(param1[1]))) + if main_affix: + main_stat = main_affix.AffixID + main_property = main_affix.Property + + for param in [param2, param3, param4, param5]: + if param and len(param) >= 3 and ":" in param: + parts = param.split(":") + if len(parts) == 2 and all(part.isdigit() for part in parts): + sub_affix_data = ResourceManager.instance().find_all_by_index(RelicSubAffixConfigData, relics.SubAffixGroup) + for affix in sub_affix_data: + if affix.AffixID == int(parts[0]) and affix.Property != main_property: + sub_affix_list.append(SubAffix(id=int(parts[0]), count=int(parts[1]), step=int(parts[1]) * 2)) + item = session.player.add_relic(item_id,main_stat,sub_affix_list) + if item: + session.player.inventory_manager[item.unique_id] = item + sync = True + if sync: + await session.notify(session.player.PlayerSyncProto()) + return "GIVE" + except Exception as e: + print(e) diff --git a/game_server/game/chat/command/giveall.py b/game_server/game/chat/command/giveall.py new file mode 100644 index 0000000..121f9eb --- /dev/null +++ b/game_server/game/chat/command/giveall.py @@ -0,0 +1,48 @@ +from game_server.game.chat.decorators import Command +from game_server.net.session import PlayerSession +from game_server.resource import ResourceManager +from game_server.resource.configdb.avatar_config import AvatarConfig +from game_server.resource.configdb.equipment_config import EquipmentConfig +from game_server.resource.configdb.relic_config import RelicConfigData + +@Command( + prefix="giveall", + usage="/giveall", +) +async def execute(session:PlayerSession, text): + try: + sync = False + if text == "avatars": + avatars = ResourceManager.instance().values(AvatarConfig) + for avatar in avatars: + if avatar.AvatarID == 1224 or avatar.AvatarID >= 7000: + continue + if session.player.avatar_mananger.get(avatar.AvatarID): + continue + data = session.player.add_avatar(avatar.AvatarID) + if data: + session.player.avatar_mananger[data.avatar_id] = data + sync = True + + if text == "lightcones": + lightcones = ResourceManager.instance().values(EquipmentConfig) + for lightcone in lightcones: + item = session.player.add_lightcone(lightcone.EquipmentID) + if item: + session.player.inventory_manager[item.unique_id] = item + sync = True + + if text == "relics": + relics = ResourceManager.instance().values(RelicConfigData) + for relic in relics: + item = session.player.add_relic(relic.ID) + if item: + session.player.inventory_manager[item.unique_id] = item + sync = True + + if sync: + await session.notify(session.player.PlayerSyncProto()) + + return "GIVEALL" + except Exception as e: + print(e) diff --git a/game_server/game/chat/command_handler.py b/game_server/game/chat/command_handler.py new file mode 100644 index 0000000..89c7421 --- /dev/null +++ b/game_server/game/chat/command_handler.py @@ -0,0 +1,53 @@ +from utils.logger import Info +from game_server.game.chat.decorators import command_registry +from game_server.net.session import PlayerSession +import game_server.game.chat.command # noqa: F401 + + +class CommandHandler: + def load_commands(self): + registered_commands = ", ".join( + item.prefix for item in command_registry.values() if not item.is_alias + ) + + Info( + f"[BOOT] [CommandHandler] Registered {len(command_registry)} game commands => {registered_commands}" + ) + + def parse_command(self, content: str): + content = content.lstrip("/") + parts = content.split(maxsplit=1) + if len(parts) < 2: + return parts[0], "" + + return parts[0], parts[1] + + def print_help(self): + result = "Available commands:\n" + for index, (_, func) in enumerate(command_registry.items()): + result += f"{index+1}) {func.usage}\n\n" + return result + + async def handle_command(self, session: PlayerSession, content: str): + if content == "/help": + return self.print_help() + + command_label, args = self.parse_command(content) + command_func = command_registry.get(command_label) + + if command_func is not None: + func_args_cnt = command_func.__code__.co_argcount - 1 + args_list = args.split()[:func_args_cnt] + + if args_list and args_list[0] == "help": + return f"Usage: {command_func.usage}" + + try: + return await command_func(session, *args_list) + except TypeError: + return f"Usage: {command_func.usage}" + + return None + + +handler = CommandHandler() diff --git a/game_server/game/chat/decorators.py b/game_server/game/chat/decorators.py new file mode 100644 index 0000000..52a19c2 --- /dev/null +++ b/game_server/game/chat/decorators.py @@ -0,0 +1,21 @@ +from typing import Dict, Type + + +command_registry: Dict[str, Type] = {} + + +def Command(prefix: str, usage: str, aliases: list = list()): + def decorator(func): + func.usage = usage + func.prefix = prefix + func.is_alias = False + command_registry[prefix] = func + + # Register alias if exist + for alias in aliases: + func.is_alias = True + command_registry[alias] = func + + return func + + return decorator diff --git a/game_server/game/enums/avatar/relic_type.py b/game_server/game/enums/avatar/relic_type.py new file mode 100644 index 0000000..7a1c741 --- /dev/null +++ b/game_server/game/enums/avatar/relic_type.py @@ -0,0 +1,10 @@ +from enum import Enum + +class RelicTypeEnum(Enum): + Unknown = 0 + HEAD = 1 + HAND = 2 + BODY = 3 + FOOT = 4 + NECK = 5 + OBJECT = 6 diff --git a/game_server/game/enums/scene/game_mode_type.py b/game_server/game/enums/scene/game_mode_type.py new file mode 100644 index 0000000..8fbc8ef --- /dev/null +++ b/game_server/game/enums/scene/game_mode_type.py @@ -0,0 +1,12 @@ +from enum import Enum + +class GameModeTypeEnum(Enum): + Unknown = 0 + Town = 1 + Maze = 2 + Train = 3 + Challenge = 4 + Rogue = 5 + Raid = 6 + AetherDivide = 7 + TrialActivity = 8 \ No newline at end of file diff --git a/game_server/game/items/relic_manager.py b/game_server/game/items/relic_manager.py new file mode 100644 index 0000000..65a9997 --- /dev/null +++ b/game_server/game/items/relic_manager.py @@ -0,0 +1,57 @@ +import random +from pydantic import BaseModel +from game_server.resource import ResourceManager +from game_server.resource.configdb.relic_config import RelicConfigData +from game_server.resource.configdb.relic_main_affix_config import RelicMainAffixConfigData +from game_server.resource.configdb.relic_sub_affix_config import RelicSubAffixConfigData + + +class SubAffix(BaseModel): + id: int + count: int + step: int + +class MainAffix(BaseModel): + AffixID: int + Property: str + +class RelicManager(BaseModel): + def GetRandomRelicMainAffix(self, itemid) -> MainAffix: + config = ResourceManager.instance().find_by_index(RelicConfigData, itemid) + if not config: + return MainAffix(AffixID=0, Property=None) + + affixes = [ + affix + for affix in ResourceManager.instance().values(RelicMainAffixConfigData) + if config.MainAffixGroup == affix.GroupID + ] + + if not affixes: + return MainAffix(AffixID=0, Property=None) + + selected_affix = random.choice(affixes) + return MainAffix(AffixID=selected_affix.AffixID, Property=selected_affix.Property) + + def GetRandomRelicSubAffix(self, itemid: int, property: str, loop: int, affix_list: list[SubAffix] = []) -> list[SubAffix]: + config = ResourceManager.instance().find_by_index(RelicConfigData, itemid) + if not config: + return [] + + affix_ids_in_list = {affix.id for affix in affix_list} + affixes = [ + affix + for affix in ResourceManager.instance().values(RelicSubAffixConfigData) + if config.SubAffixGroup == affix.GroupID and affix.Property != property and affix.AffixID not in affix_ids_in_list + ] + + selected_affixes = random.sample(affixes, 4 - len(affix_ids_in_list)) + + sub_affix_list = [] + for affix in selected_affixes: + count = random.randint(1, loop) + step = count * 2 + sub_affix_list.append(SubAffix(id=affix.AffixID, count=count, step=step)) + + return sub_affix_list + diff --git a/game_server/game/motion/motion_info.py b/game_server/game/motion/motion_info.py new file mode 100644 index 0000000..efd6dce --- /dev/null +++ b/game_server/game/motion/motion_info.py @@ -0,0 +1,22 @@ +from pydantic import BaseModel +from rail_proto.lib import MotionInfo,Vector + +class Motion(BaseModel): + x: float + y: float + z: float + rotY: float + + def ToProto(self) -> MotionInfo: + return MotionInfo( + pos=Vector( + x=int(self.x*1000), + y=int(self.y*1000), + z=int(self.z*1000) + ), + rot=Vector( + x=0, + y=int(self.rotY*1000), + z=0 + ) + ) diff --git a/game_server/game/player/player_manager.py b/game_server/game/player/player_manager.py new file mode 100644 index 0000000..7f77c4e --- /dev/null +++ b/game_server/game/player/player_manager.py @@ -0,0 +1,171 @@ +from pydantic import BaseModel +from database.player.player_data import PlayerData,players_collection +from database.avatar.avatar_data import AvatarData,get_all_avatars_by_uid,avatars_collection +from database.lineup.lineup_data import LineupData,get_all_lineup_by_uid,lineups_collection +from database.inventory.inventory_data import InventoryData,get_all_items_by_uid,items_collection +from game_server.game.scene.scene_manager import SceneManager +from typing import Optional +from rail_proto.lib import ( + PlayerSyncScNotify, + AvatarSync +) +from pymongo import UpdateOne +from utils.logger import Error + + +class PlayerManager(BaseModel): + data : PlayerData = PlayerData() + avatar_mananger: dict[int,AvatarData] = {} + lineup_manager: dict[int,LineupData] = {} + inventory_manager: dict[int,InventoryData] = {} + scene_manager: SceneManager = None + + def init_default(self): + self.add_all_avatars() + self.add_all_lineups() + self.add_all_items() + self.scene_manager = SceneManager( + entry_id=self.data.entry_id + ) + + def save_all(self): + self.save_player_data_bulk() + self.save_all_avatars_bulk() + self.save_all_lineups_bulk() + self.save_all_items_bulk() + + def add_all_avatars(self): + avatars = get_all_avatars_by_uid(uid=self.data.uid) + if not avatars: + avatar = AvatarData( + uid=self.data.uid, + avatar_id=self.data.cur_basic_type + ).add_avatar() + self.avatar_mananger[self.data.cur_basic_type] = avatar + + for avatar in avatars: + self.avatar_mananger[avatar.avatar_id] = avatar + + def add_all_lineups(self): + lineups = get_all_lineup_by_uid(uid=self.data.uid) + if not lineups: + lineup = LineupData( + uid=self.data.uid, + index=0, + name="", + avatar_list=[self.data.cur_basic_type] + ).add_lineup() + self.lineup_manager[lineup.index] = lineup + for lineup in lineups: + self.lineup_manager[lineup.index] = lineup + + def add_all_items(self): + items = get_all_items_by_uid(uid=self.data.uid) + for item in items: + self.inventory_manager[item.unique_id] = item + + def add_avatar(self,avatar_id:int) -> Optional[AvatarData]: + avatar = self.avatar_mananger.get(avatar_id) + if avatar: + return None + + avatar = AvatarData(uid=self.data.uid,avatar_id=avatar_id).add_avatar() + if avatar: + return avatar + return None + + def add_lineup(self,avatar_ids: list[int],index=0,name=""): + LineupData( + uid=self.data.uid, + index=index, + name=name, + avatar_list=avatar_ids + ).add_lineup() + + def add_lightcone(self,lightcone_id: int, rank=1) -> Optional[InventoryData]: + item = InventoryData( + uid=self.data.uid, + item_id=lightcone_id, + rank=rank + ).add_lightcone() + if item: + return item + return None + + def add_relic(self,relic_id: int, main_affix=0, sub_affix=[]) -> Optional[InventoryData]: + item = InventoryData( + uid=self.data.uid, + item_id=relic_id, + main_affix=main_affix, + sub_affix=sub_affix + ).add_relic() + if item: + return item + return None + + + def PlayerSyncProto(self) -> PlayerSyncScNotify: + avatars = [] + for avatar_id,avatar in self.avatar_mananger.items(): + avatars.append(avatar.ToProto()) + + lightcones = [] + for unique_id,item in self.inventory_manager.items(): + if item.main_type == 1: + lightcones.append(item.ToProto()) + + relics = [] + for unique_id,item in self.inventory_manager.items(): + if item.main_type == 2: + relics.append(item.ToProto()) + return PlayerSyncScNotify( + equipment_list=lightcones, + relic_list=relics, + avatar_sync= + AvatarSync( + avatar_list=avatars + ), + basic_info=self.data.ToProto() + ) + + def save_player_data_bulk(self): + try: + player_data = self.data.model_dump() + player_data["uid"] = self.data.uid + query = {"uid": self.data.uid} + players_collection.update_one(query, {"$set": player_data}, upsert=True) + except Exception as e: + Error(f"Error save player data: {e}") + + def save_all_avatars_bulk(self): + operations = [] + for avatar in self.avatar_mananger.values(): + avatar_data = avatar.model_dump() + avatar_data["uid"] = avatar.uid + query = {"uid": avatar.uid, "avatar_id": avatar.avatar_id} + operations.append(UpdateOne(query, {"$set": avatar_data}, upsert=True)) + + if operations: + avatars_collection.bulk_write(operations) + + def save_all_lineups_bulk(self): + operations = [] + for lineup in self.lineup_manager.values(): + lineup_data = lineup.model_dump() + lineup_data["uid"] = lineup.uid + query = {"uid": lineup.uid, "index": lineup.index} + operations.append(UpdateOne(query, {"$set": lineup_data}, upsert=True)) + + if operations: + lineups_collection.bulk_write(operations) + + def save_all_items_bulk(self): + operations = [] + for item in self.inventory_manager.values(): + item_data = item.model_dump() + item_data["uid"] = item.uid + query = {"uid": item.uid, "unique_id": item.unique_id} + operations.append(UpdateOne(query, {"$set": item_data}, upsert=True)) + + if operations: + items_collection.bulk_write(operations) \ No newline at end of file diff --git a/game_server/game/scene/scene_manager.py b/game_server/game/scene/scene_manager.py new file mode 100644 index 0000000..c5f52b1 --- /dev/null +++ b/game_server/game/scene/scene_manager.py @@ -0,0 +1,165 @@ +from pydantic import BaseModel +from game_server.game.enums.scene.game_mode_type import GameModeTypeEnum +from game_server.resource import ResourceManager +from game_server.resource.configdb.maze_plane import MazePlaneData +from game_server.resource.configdb.map_entrance import MapEntranceData +from game_server.game.motion.motion_info import Motion +from rail_proto.lib import ( + SceneEntityGroupInfo, + SceneInfo, + SceneEntityInfo, + SceneEntityGroupInfo, + ScenePropInfo, + SceneNpcInfo, + SceneNpcMonsterInfo, + SceneActorInfo, + AvatarType +) + +class SceneManager(BaseModel): + entry_id: int + plane_id: int = 0 + floor_id: int = 0 + game_mode_type: int = 0 + world_id: int = 0 + teleport_id: int = 0 + entity_group_list: list[SceneEntityGroupInfo] = [] + entities: dict[int,SceneEntityInfo] = {} + battle_monster: list[SceneEntityInfo] = [] + + def ToProto(self,session) -> SceneInfo: + prop_entity_id = 10 + npc_entity_id = 10_000 + monster_entity_id = 20_000 + entrance = ResourceManager.instance().find_by_index(MapEntranceData, self.entry_id) + maze_plane = ResourceManager.instance().find_by_index(MazePlaneData, entrance.PlaneID) + floor_infos = entrance.floor_infos.get(self.entry_id) + proto = SceneInfo( + entry_id=self.entry_id, + plane_id=entrance.PlaneID, + floor_id=entrance.FloorID, + ) + + proto.game_mode_type = GameModeTypeEnum[maze_plane.PlaneType].value + if maze_plane.WorldID == 100: + maze_plane.WorldID = 401 + proto.world_id = maze_plane.WorldID + + loaded_npc = [13199,13321,1313,13227,13190,13191,13192,13141,13246,13407 ,13223,13152] + loaded_group = [] + groups = [] + for group_id,group in floor_infos.groups.items(): + if group.LoadSide == "Client": + continue + # if group_id in loaded_group: + # continue + # if group_id > 150 and group_id < 200: + # continue + # if group_id > 300: + # continue + if group_id in groups: + continue + groups.append(group_id) + group_info = SceneEntityGroupInfo( + group_id=group_id + ) + + for prop in group.PropList: + prop_entity_id += 1 + prop_entity_info = SceneEntityInfo( + inst_id=prop.ID, + group_id=group_id, + motion=Motion( + x=prop.PosX, + y=prop.PosY, + z=prop.PosZ, + rotY=prop.RotY + ).ToProto(), + prop=ScenePropInfo( + prop_id=prop.PropID, + prop_state=8 if prop.MappingInfoID > 0 else (1 if prop.State == 0 else prop.State) + ), + entity_id=prop_entity_id + ) + group_info.entity_list.append(prop_entity_info) + if self.teleport_id > 0 and self.teleport_id == prop.MappingInfoID: + for anchor in group.AnchorList: + if group.id == prop.AnchorGroupID and anchor.ID == prop.AnchorID: + session.player.data.pos.x = int(anchor.PosX) + session.player.data.pos.y = int(anchor.PosY) + session.player.data.pos.z = int(anchor.PosZ) + session.player.data.rot.y = int(anchor.RotY) + + for npc in group.NPCList: + if npc.NPCID in loaded_npc: + continue + loaded_npc.append(npc.NPCID) + npc_entity_id += 1 + npc_entity_info = SceneEntityInfo( + inst_id=npc.ID, + group_id=group_id, + entity_id=npc_entity_id, + motion=Motion( + x=npc.PosX, + y=npc.PosY, + z=npc.PosZ, + rotY=npc.RotY + ).ToProto(), + npc=SceneNpcInfo( + npc_id=npc.NPCID + ) + ) + group_info.entity_list.append(npc_entity_info) + + for monster in group.MonsterList: + monster_entity_id += 1 + monster_entity_info = SceneEntityInfo( + inst_id=monster.ID, + group_id=group_id, + entity_id=monster_entity_id, + motion=Motion( + x=monster.PosX, + y=monster.PosY, + z=monster.PosZ, + rotY=monster.RotY + ).ToProto(), + npc_monster=SceneNpcMonsterInfo( + monster_id=monster.NPCMonsterID, + event_id=monster.EventID, + world_level=6 + ) + ) + group_info.entity_list.append(monster_entity_info) + session.player.scene_manager.entities[monster_entity_id] = monster_entity_info + proto.entity_group_list.append(group_info) + + player_pos = Motion( + x=session.player.data.pos.x, + y=session.player.data.pos.y, + z=session.player.data.pos.z, + rotY=session.player.data.rot.y + ).ToProto() + player_group = SceneEntityGroupInfo(state=0,group_id=0) + for avatar_id in session.player.lineup_manager.get(session.player.data.cur_lineup).avatar_list: + player_entity = SceneEntityInfo( + inst_id=0, + entity_id=avatar_id << 20, + motion=player_pos, + actor=SceneActorInfo( + avatar_type=AvatarType.AVATAR_FORMAL_TYPE.value, + base_avatar_id=avatar_id, + uid=session.player.data.uid, + ) + ) + player_group.entity_list.append(player_entity) + proto.entity_group_list.append(player_group) + session.player.data.entry_id = self.entry_id + session.player.data.plane_id = entrance.PlaneID + session.player.data.floor_id = entrance.FloorID + return proto + + + + + + diff --git a/game_server/handlers/ChangeLineupLeaderCsReq.py b/game_server/handlers/ChangeLineupLeaderCsReq.py new file mode 100644 index 0000000..16105f5 --- /dev/null +++ b/game_server/handlers/ChangeLineupLeaderCsReq.py @@ -0,0 +1,13 @@ +import betterproto +from game_server.net.session import PlayerSession +from rail_proto.lib import ( + ChangeLineupLeaderCsReq, + ChangeLineupLeaderScRsp +) + +async def handle(session: PlayerSession, msg: ChangeLineupLeaderCsReq) -> betterproto.Message: + session.player.lineup_manager.get(session.player.data.cur_lineup,None).leader_slot = msg.slot + return ChangeLineupLeaderScRsp( + retcode=0, + slot=msg.slot + ) \ No newline at end of file diff --git a/game_server/handlers/DressAvatarCsReq.py b/game_server/handlers/DressAvatarCsReq.py new file mode 100644 index 0000000..999b269 --- /dev/null +++ b/game_server/handlers/DressAvatarCsReq.py @@ -0,0 +1,38 @@ +import betterproto +from game_server.net.session import PlayerSession +from rail_proto.lib import ( + DressAvatarCsReq, + DressAvatarScRsp +) + +async def handle(session: PlayerSession, msg: DressAvatarCsReq) -> betterproto.Message: + equipment = session.player.inventory_manager.get(msg.equipment_unique_id) + target_avatar = session.player.avatar_mananger.get(msg.avatar_id) + + if not equipment or not target_avatar: + return DressAvatarScRsp() + + previous_avatar = session.player.avatar_mananger.get(equipment.equip_avatar) + if previous_avatar: + if previous_avatar.lightcone_id > 0 and target_avatar.lightcone_id > 0: + target_equipment = session.player.inventory_manager.get(target_avatar.lightcone_id) + target_avatar.lightcone_id, previous_avatar.lightcone_id = previous_avatar.lightcone_id, target_avatar.lightcone_id + target_equipment.equip_avatar, equipment.equip_avatar = previous_avatar.avatar_id, target_avatar.avatar_id + #target_equipment.save_item() + else: + previous_avatar.lightcone_id = 0 + equipment.equip_avatar = target_avatar.avatar_id + target_avatar.lightcone_id = equipment.unique_id + #previous_avatar.save_avatar() + else: + if target_avatar.lightcone_id > 0: + previous_equipment = session.player.inventory_manager.get(target_avatar.lightcone_id) + previous_equipment.equip_avatar = 0 + #previous_equipment.save_item() + equipment.equip_avatar = target_avatar.avatar_id + target_avatar.lightcone_id = equipment.unique_id + + #equipment.save_item() + #target_avatar.save_avatar() + await session.notify(session.player.PlayerSyncProto()) + return DressAvatarScRsp(retcode=0) \ No newline at end of file diff --git a/game_server/handlers/DressRelicAvatarCsReq.py b/game_server/handlers/DressRelicAvatarCsReq.py new file mode 100644 index 0000000..11658d8 --- /dev/null +++ b/game_server/handlers/DressRelicAvatarCsReq.py @@ -0,0 +1,73 @@ +import betterproto +from game_server.net.session import PlayerSession +from rail_proto.lib import ( + DressRelicAvatarCsReq, + DressRelicAvatarScRsp +) + +async def handle(session: PlayerSession, msg: DressRelicAvatarCsReq) -> betterproto.Message: + target_avatar = session.player.avatar_mananger.get(msg.avatar_id) + if not target_avatar: + return DressRelicAvatarScRsp() + + for relic_data in msg.switch_list: + relic = session.player.inventory_manager.get(relic_data.relic_unique_id) + if not relic: + continue + + relic_sub_type = str(relic.sub_type) + current_relic_id = target_avatar.relic_ids.get(relic_sub_type, 0) + previous_avatar = session.player.avatar_mananger.get(relic.equip_avatar) + + if previous_avatar: + previous_relic_id = previous_avatar.relic_ids.get(relic_sub_type, 0) + + if previous_relic_id > 0 and current_relic_id > 0: + current_relic = session.player.inventory_manager.get(current_relic_id) + previous_relic = session.player.inventory_manager.get(previous_relic_id) + + if current_relic and previous_relic: + previous_avatar.relic_ids[relic_sub_type] = current_relic.unique_id + current_relic.equip_avatar = previous_avatar.avatar_id + + target_avatar.relic_ids[relic_sub_type] = previous_relic.unique_id + previous_relic.equip_avatar = target_avatar.avatar_id + + #current_relic.save_item() + #previous_relic.save_item() + + elif previous_relic_id > 0: + previous_relic = session.player.inventory_manager.get(previous_relic_id) + if previous_relic: + previous_relic.equip_avatar = 0 + #previous_relic.save_item() + previous_avatar.relic_ids[relic_sub_type] = 0 + + elif current_relic_id > 0: + current_relic = session.player.inventory_manager.get(current_relic_id) + if current_relic: + current_relic.equip_avatar = 0 + #current_relic.save_item() + target_avatar.relic_ids[relic_sub_type] = 0 + + target_avatar.relic_ids[relic_sub_type] = relic.unique_id + relic.equip_avatar = target_avatar.avatar_id + #relic.save_item() + #previous_avatar.save_avatar() + + else: + if current_relic_id > 0: + current_relic = session.player.inventory_manager.get(current_relic_id) + if current_relic: + current_relic.equip_avatar = 0 + #current_relic.save_item() + + target_avatar.relic_ids[relic_sub_type] = relic.unique_id + relic.equip_avatar = target_avatar.avatar_id + #relic.save_item() + + #target_avatar.save_avatar() + + await session.notify(session.player.PlayerSyncProto()) + + return DressRelicAvatarScRsp(retcode=0) diff --git a/game_server/handlers/EnterSceneCsReq.py b/game_server/handlers/EnterSceneCsReq.py new file mode 100644 index 0000000..fadc24f --- /dev/null +++ b/game_server/handlers/EnterSceneCsReq.py @@ -0,0 +1,39 @@ +import betterproto +from game_server.net.session import PlayerSession +from game_server.game.motion.motion_info import Motion +from rail_proto.lib import ( + EnterSceneCsReq, + EnterSceneScRsp, + EnterSceneByServerScNotify, + SceneEntityMoveScNotify +) + +async def handle(session: PlayerSession, msg: EnterSceneCsReq) -> betterproto.Message: + scene = session.player.scene_manager + scene.entry_id = msg.entry_id + if msg.teleport_id > 0: + session.player.scene_manager.teleport_id = msg.teleport_id + scene_proto = scene.ToProto(session) + lineup = session.player.lineup_manager.get(session.player.data.cur_lineup).ToProto() + session.pending_notify( + EnterSceneByServerScNotify( + scene=scene_proto, + lineup=lineup + ) + ) + session.pending_notify( + SceneEntityMoveScNotify( + entry_id=session.player.scene_manager.entry_id, + motion=Motion( + x=session.player.data.pos.x, + y=session.player.data.pos.y, + z=session.player.data.pos.z, + rotY=session.player.data.rot.y, + ).ToProto() + ) + ) + scene.teleport_id = 0 + #session.player.data.save_player_data() + return EnterSceneScRsp( + retcode=0 + ) \ No newline at end of file diff --git a/game_server/handlers/GetAllLineupDataCsReq.py b/game_server/handlers/GetAllLineupDataCsReq.py new file mode 100644 index 0000000..639d45b --- /dev/null +++ b/game_server/handlers/GetAllLineupDataCsReq.py @@ -0,0 +1,16 @@ +import betterproto +from game_server.net.session import PlayerSession +from rail_proto.lib import ( + GetAllLineupDataCsReq, + GetAllLineupDataScRsp, + LineupInfo +) + +async def handle(session: PlayerSession, msg: GetAllLineupDataCsReq) -> betterproto.Message: + lineups: list[LineupInfo] = [] + for index,lineup in session.player.lineup_manager.items(): + lineups.append(lineup.ToProto()) + return GetAllLineupDataScRsp( + retcode=0, + lineup_list=lineups + ) \ No newline at end of file diff --git a/game_server/handlers/GetAvatarDataCsReq.py b/game_server/handlers/GetAvatarDataCsReq.py new file mode 100644 index 0000000..069fc04 --- /dev/null +++ b/game_server/handlers/GetAvatarDataCsReq.py @@ -0,0 +1,16 @@ +import betterproto +from game_server.net.session import PlayerSession +from rail_proto.lib import ( + GetAvatarDataCsReq, + GetAvatarDataScRsp, + Avatar +) + +async def handle(session: PlayerSession, msg: GetAvatarDataCsReq) -> betterproto.Message: + avatars: list[Avatar] = [] + for avatar_id,avatar in session.player.avatar_mananger.items(): + avatars.append(avatar.ToProto()) + return GetAvatarDataScRsp( + retcode=0, + avatar_list=avatars + ) \ No newline at end of file diff --git a/game_server/handlers/GetBagCsReq.py b/game_server/handlers/GetBagCsReq.py new file mode 100644 index 0000000..ceaf4fa --- /dev/null +++ b/game_server/handlers/GetBagCsReq.py @@ -0,0 +1,15 @@ +import betterproto +from game_server.net.session import PlayerSession +from rail_proto.lib import ( + GetBagCsReq, + GetBagScRsp +) + +async def handle(session: PlayerSession, msg: GetBagCsReq) -> betterproto.Message: + equipment = [equipment.ToProto() for unique_id,equipment in session.player.inventory_manager.items() if equipment.main_type == 1] + relics = [relic.ToProto() for unique_id,relic in session.player.inventory_manager.items() if relic.main_type == 2] + return GetBagScRsp( + retcode=0, + equipment_list=equipment, + relic_list=relics + ) \ No newline at end of file diff --git a/game_server/handlers/GetBasicInfoCsReq.py b/game_server/handlers/GetBasicInfoCsReq.py new file mode 100644 index 0000000..b4620de --- /dev/null +++ b/game_server/handlers/GetBasicInfoCsReq.py @@ -0,0 +1,24 @@ +import betterproto +from game_server.net.session import PlayerSession +from rail_proto.lib import ( + GetBasicInfoCsReq, + GetBasicInfoScRsp, + PlayerSettingInfo +) + +async def handle(session: PlayerSession, msg: GetBasicInfoCsReq) -> betterproto.Message: + return GetBasicInfoScRsp( + retcode=0, + player_setting_info=PlayerSettingInfo( + mmmnjchemfn=True, + kapdimgjlnf=True, + ilfalcdlaol=True, + gmjanojmkce=True, + pbkbglhhkpe=True, + nkekibnjmpa=True, + kjncckhjfhe=True, + aicnfaobcpi=True, + aponeidmphl=True, + njfmiljofok=True + ) + ) \ No newline at end of file diff --git a/game_server/handlers/GetChallengeCsReq.py b/game_server/handlers/GetChallengeCsReq.py new file mode 100644 index 0000000..fae251d --- /dev/null +++ b/game_server/handlers/GetChallengeCsReq.py @@ -0,0 +1,20 @@ +import betterproto +from game_server.net.session import PlayerSession +from game_server.resource import ResourceManager +from game_server.resource.configdb.challenge_maze_config import ChallengeMazeConfig +from rail_proto.lib import ( + GetChallengeCsReq, + GetChallengeScRsp, + Challenge +) + +async def handle(session: PlayerSession, msg: GetChallengeCsReq) -> betterproto.Message: + return GetChallengeScRsp( + retcode=0, + challenge_list=[ + Challenge( + challenge_id=challenge.ID + ) + for challenge in ResourceManager.instance().values(ChallengeMazeConfig) + ] + ) \ No newline at end of file diff --git a/game_server/handlers/GetCurLineupDataCsReq.py b/game_server/handlers/GetCurLineupDataCsReq.py new file mode 100644 index 0000000..d992a6f --- /dev/null +++ b/game_server/handlers/GetCurLineupDataCsReq.py @@ -0,0 +1,12 @@ +import betterproto +from game_server.net.session import PlayerSession +from rail_proto.lib import ( + GetCurLineupDataCsReq, + GetCurLineupDataScRsp +) + +async def handle(session: PlayerSession, msg: GetCurLineupDataCsReq) -> betterproto.Message: + return GetCurLineupDataScRsp( + retcode=0, + lineup=session.player.lineup_manager.get(session.player.data.cur_lineup,None).ToProto() + ) \ No newline at end of file diff --git a/game_server/handlers/GetCurSceneInfoCsReq.py b/game_server/handlers/GetCurSceneInfoCsReq.py new file mode 100644 index 0000000..623fd30 --- /dev/null +++ b/game_server/handlers/GetCurSceneInfoCsReq.py @@ -0,0 +1,25 @@ +import betterproto +from game_server.net.session import PlayerSession +from game_server.game.motion.motion_info import Motion +from rail_proto.lib import ( + GetCurSceneInfoCsReq, + GetCurSceneInfoScRsp, + SceneEntityMoveScNotify +) + +async def handle(session: PlayerSession, msg: GetCurSceneInfoCsReq) -> betterproto.Message: + session.pending_notify( + SceneEntityMoveScNotify( + entry_id=session.player.scene_manager.entry_id, + motion=Motion( + x=session.player.data.pos.x, + y=session.player.data.pos.y, + z=session.player.data.pos.z, + rotY=session.player.data.rot.y, + ).ToProto() + ) + ) + return GetCurSceneInfoScRsp( + retcode=0, + scene=session.player.scene_manager.ToProto(session=session) + ) \ No newline at end of file diff --git a/game_server/handlers/GetFriendListInfoCsReq.py b/game_server/handlers/GetFriendListInfoCsReq.py new file mode 100644 index 0000000..853e2d7 --- /dev/null +++ b/game_server/handlers/GetFriendListInfoCsReq.py @@ -0,0 +1,29 @@ +import betterproto +from game_server.net.session import PlayerSession +from rail_proto.lib import ( + GetFriendListInfoCsReq, + GetFriendListInfoScRsp, + FriendSimpleInfo, + PlayerSimpleInfo, + PlatformType, + FriendOnlineStatus +) + +async def handle(session: PlayerSession, msg: GetFriendListInfoCsReq) -> betterproto.Message: + return GetFriendListInfoScRsp( + retcode=0, + friend_list=[ + FriendSimpleInfo( + player_info=PlayerSimpleInfo( + uid=69, + level=1, + chat_bubble_id=220004, + head_icon=201310, + platform=PlatformType.PC.value, + online_status=FriendOnlineStatus.FRIEND_ONLINE_STATUS_ONLINE.value, + is_banned=False, + nickname="FireFly" + ) + ) + ] + ) \ No newline at end of file diff --git a/game_server/handlers/GetMissionStatusCsReq.py b/game_server/handlers/GetMissionStatusCsReq.py new file mode 100644 index 0000000..57a9af6 --- /dev/null +++ b/game_server/handlers/GetMissionStatusCsReq.py @@ -0,0 +1,26 @@ +import betterproto +from game_server.net.session import PlayerSession +from game_server.resource import ResourceManager +from game_server.resource.configdb.main_mission import MainMissionData +from rail_proto.lib import ( + GetMissionStatusCsReq, + GetMissionStatusScRsp, + Mission, + MissionStatus +) + +async def handle(session: PlayerSession, msg: GetMissionStatusCsReq) -> betterproto.Message: + return GetMissionStatusScRsp( + retcode=0, + finished_main_mission_id_list=[mission.MainMissionID for mission in ResourceManager.instance().values(MainMissionData)], + sub_mission_status_list=[ + Mission( + id=mission_id, + progress=1, + status=MissionStatus.MISSION_FINISH.value + ) + for mission_id in msg.sub_mission_id_list + ], + unfinished_main_mission_id_list=[], + disabled_main_mission_id_list=[] + ) \ No newline at end of file diff --git a/game_server/handlers/GetNpcTakenRewardCsReq.py b/game_server/handlers/GetNpcTakenRewardCsReq.py new file mode 100644 index 0000000..7d96938 --- /dev/null +++ b/game_server/handlers/GetNpcTakenRewardCsReq.py @@ -0,0 +1,13 @@ +import betterproto +from game_server.net.session import PlayerSession +from rail_proto.lib import ( + GetNpcTakenRewardCsReq, + GetNpcTakenRewardScRsp, + PlayerSettingInfo +) + +async def handle(session: PlayerSession, msg: GetNpcTakenRewardCsReq) -> betterproto.Message: + return GetNpcTakenRewardScRsp( + retcode=0, + npc_id=msg.npc_id + ) \ No newline at end of file diff --git a/game_server/handlers/GetPhoneDataCsReq.py b/game_server/handlers/GetPhoneDataCsReq.py new file mode 100644 index 0000000..adfb91b --- /dev/null +++ b/game_server/handlers/GetPhoneDataCsReq.py @@ -0,0 +1,17 @@ +import betterproto +from game_server.net.session import PlayerSession +from game_server.resource import ResourceManager +from game_server.resource.configdb.item_config import ItemConfig +from rail_proto.lib import ( + GetPhoneDataCsReq, + GetPhoneDataScRsp +) + +async def handle(session: PlayerSession, msg: GetPhoneDataCsReq) -> betterproto.Message: + return GetPhoneDataScRsp( + retcode=0, + cur_chat_bubble=session.player.data.chat_bubble, + cur_phone_theme=session.player.data.phone_theme, + owned_chat_bubbles=[item.ID for item in ResourceManager.instance().values(ItemConfig) if item.ItemSubType == "ChatBubble"], + owned_phone_themes=[item.ID for item in ResourceManager.instance().values(ItemConfig) if item.ItemSubType == "PhoneTheme"] + ) \ No newline at end of file diff --git a/game_server/handlers/GetPlayerBoardDataCsReq.py b/game_server/handlers/GetPlayerBoardDataCsReq.py new file mode 100644 index 0000000..3a6aa96 --- /dev/null +++ b/game_server/handlers/GetPlayerBoardDataCsReq.py @@ -0,0 +1,21 @@ +import betterproto +from game_server.net.session import PlayerSession +from game_server.resource import ResourceManager +from game_server.resource.configdb.player_icon_config import PlayerIconConfig +from rail_proto.lib import ( + GetPlayerBoardDataCsReq, + GetPlayerBoardDataScRsp, + HeadIconData +) + +async def handle(session: PlayerSession, msg: GetPlayerBoardDataCsReq) -> betterproto.Message: + return GetPlayerBoardDataScRsp( + retcode=0, + current_head_icon_id=session.player.data.head_icon, + unlocked_head_icon_list=[ + HeadIconData( + id=icon.ID + ) + for icon in ResourceManager.instance().values(PlayerIconConfig) + ] + ) \ No newline at end of file diff --git a/game_server/handlers/GetPrivateChatHistoryCsReq.py b/game_server/handlers/GetPrivateChatHistoryCsReq.py new file mode 100644 index 0000000..15c50af --- /dev/null +++ b/game_server/handlers/GetPrivateChatHistoryCsReq.py @@ -0,0 +1,26 @@ +import betterproto +from game_server.net.session import PlayerSession +from rail_proto.lib import ( + GetPrivateChatHistoryCsReq, + GetPrivateChatHistoryScRsp, + ChatMessageData, + MsgType +) + +async def handle(session: PlayerSession, msg: GetPrivateChatHistoryCsReq) -> betterproto.Message: + return GetPrivateChatHistoryScRsp( + retcode=0, + contact_side=msg.contact_side, + chat_message_list=[ + ChatMessageData( + message_type=MsgType.MSG_TYPE_CUSTOM_TEXT.value, + content="No commands available. FUCK OFF!", + sender_id=69 + ), + ChatMessageData( + message_type=MsgType.MSG_TYPE_CUSTOM_TEXT.value, + content="Hi....", + sender_id=session.player.data.uid + ) + ] + ) \ No newline at end of file diff --git a/game_server/handlers/GetSceneMapInfoCsReq.py b/game_server/handlers/GetSceneMapInfoCsReq.py new file mode 100644 index 0000000..0a4d7e9 --- /dev/null +++ b/game_server/handlers/GetSceneMapInfoCsReq.py @@ -0,0 +1,58 @@ +import betterproto +from game_server.net.session import PlayerSession +from game_server.resource import ResourceManager +from game_server.resource.configdb.map_entrance import MapEntranceData +from game_server.resource.configdb.map_default_entrance import MapDefaultEntranceData +from rail_proto.lib import ( + GetSceneMapInfoCsReq, + GetSceneMapInfoScRsp, + SceneMapInfo, + ChestInfo, + ChestType, + MazeGroup, + MazePropState +) + +async def handle(session: PlayerSession, msg: GetSceneMapInfoCsReq) -> betterproto.Message: + rsp = GetSceneMapInfoScRsp(retcode=0) + for floor_id in msg.floor_id_list: + map_default = ResourceManager.instance().find_by_index(MapDefaultEntranceData, floor_id) + if not map_default: + continue + + data = ResourceManager.instance().find_by_index(MapEntranceData, map_default.EntranceID) + + if not data: + continue + + map_info = SceneMapInfo( + retcode=0, + chest_list=[ + ChestInfo(chest_type=ChestType.MAP_INFO_CHEST_TYPE_NORMAL.value), + ChestInfo(chest_type=ChestType.MAP_INFO_CHEST_TYPE_PUZZLE.value), + ChestInfo(chest_type=ChestType.MAP_INFO_CHEST_TYPE_CHALLENGE.value) + ], + floor_id=floor_id + ) + for i in range(101): + map_info.lighten_section_list.append(i) + + level_group = data.floor_infos.get(map_default.EntranceID) + if level_group: + for group_id,group in level_group.groups.items(): + maze_group_list = MazeGroup( + group_id=group_id + ) + map_info.maze_group_list.append(maze_group_list) + for prop in group.PropList: + maze_prop = MazePropState( + group_id=group_id, + state=8 if prop.MappingInfoID > 0 else (1 if prop.State == 0 else prop.State), + config_id=prop.ID + ) + if prop.MappingInfoID > 0: + map_info.unlock_teleport_list.append(prop.MappingInfoID) + map_info.maze_prop_list.append(maze_prop) + + rsp.scene_map_info.append(map_info) + return rsp \ No newline at end of file diff --git a/game_server/handlers/PVEBattleResultCsReq.py b/game_server/handlers/PVEBattleResultCsReq.py new file mode 100644 index 0000000..974dee8 --- /dev/null +++ b/game_server/handlers/PVEBattleResultCsReq.py @@ -0,0 +1,37 @@ +import betterproto +from game_server.net.session import PlayerSession +from rail_proto.lib import ( + PVEBattleResultCsReq, + PVEBattleResultScRsp, + BattleEndStatus, + SceneGroupRefreshScNotify, + GroupRefreshInfo, + SceneGroupRefreshType, + SceneEntityRefreshInfo +) + +async def handle(session: PlayerSession, msg: PVEBattleResultCsReq) -> betterproto.Message: + if msg.end_status == BattleEndStatus.BATTLE_END_WIN.value: + await session.notify( + SceneGroupRefreshScNotify( + group_refresh_list=[ + GroupRefreshInfo( + refresh_type=SceneGroupRefreshType.SCENE_GROUP_REFRESH_TYPE_LOADED.value, + refresh_entity=[ + SceneEntityRefreshInfo( + delete_entity=monster.entity_id + ) + ], + group_id=monster.group_id + ) for monster in session.player.scene_manager.battle_monster + ], + floor_id=session.player.data.floor_id + ) + ) + for monster in session.player.scene_manager.battle_monster: + session.player.scene_manager.entities.pop(monster.entity_id, None) + return PVEBattleResultScRsp( + retcode=0, + end_status=msg.end_status, + battle_id=msg.battle_id + ) \ No newline at end of file diff --git a/game_server/handlers/PlayerGetTokenCsReq.py b/game_server/handlers/PlayerGetTokenCsReq.py new file mode 100644 index 0000000..751ed1e --- /dev/null +++ b/game_server/handlers/PlayerGetTokenCsReq.py @@ -0,0 +1,36 @@ +import betterproto +from game_server.net.session import PlayerSession +from database.account.account_data import find_account_by_uid +from database.player.player_data import PlayerData,find_player_by_uid +from database.lineup.lineup_data import LineupData +from rail_proto.lib import ( + PlayerGetTokenCsReq, + PlayerGetTokenScRsp +) +from game_server.game.player.player_manager import PlayerManager + +async def handle(session: PlayerSession, msg: PlayerGetTokenCsReq) -> betterproto.Message: + account_uid = int(msg.account_uid) + account_data=find_account_by_uid(account_uid) + if not account_data: + return PlayerGetTokenScRsp( + retcode=1003 + ) + + player_data=find_player_by_uid(account_uid) + if not player_data: + player_data=PlayerData(uid=account_uid).create_player_data(account_data.username) + session.player=PlayerManager(data=player_data) + session.player.add_avatar(8001) + session.player.add_avatar(1001) + session.player.add_lineup([8001]) + + else: + session.player=PlayerManager(data=player_data) + + + return PlayerGetTokenScRsp( + retcode=0, + uid=account_uid, + msg="OK" + ) \ No newline at end of file diff --git a/game_server/handlers/PlayerHeartBeatCsReq.py b/game_server/handlers/PlayerHeartBeatCsReq.py new file mode 100644 index 0000000..7421dc4 --- /dev/null +++ b/game_server/handlers/PlayerHeartBeatCsReq.py @@ -0,0 +1,17 @@ +import betterproto +import base64 +from game_server.net.session import PlayerSession +from utils.time import cur_timestamp_ms +from rail_proto.lib import ( + PlayerHeartBeatCsReq, + PlayerHeartBeatScRsp, + ClientDownloadData +) + +async def handle(session: PlayerSession, msg: PlayerHeartBeatCsReq) -> betterproto.Message: + return PlayerHeartBeatScRsp( + retcode=0, + client_time_ms=msg.client_time_ms, + server_time_ms=cur_timestamp_ms(), + download_data=ClientDownloadData() + ) \ No newline at end of file diff --git a/game_server/handlers/PlayerLoginCsReq.py b/game_server/handlers/PlayerLoginCsReq.py new file mode 100644 index 0000000..05b68fd --- /dev/null +++ b/game_server/handlers/PlayerLoginCsReq.py @@ -0,0 +1,30 @@ +import betterproto +from game_server.net.session import PlayerSession +from utils.time import cur_timestamp_ms +from rail_proto.lib import ( + PlayerLoginCsReq, + PlayerLoginScRsp, + PlayerBasicInfo +) +import traceback + +async def handle(session: PlayerSession, msg: PlayerLoginCsReq) -> betterproto.Message: + try: + session.player.init_default() + return PlayerLoginScRsp( + login_random=msg.login_random, + server_timestamp_ms=cur_timestamp_ms(), + stamina=240, + basic_info=PlayerBasicInfo( + nickname=session.player.data.name, + level=session.player.data.level, + exp=session.player.data.exp, + stamina=240, + mcoin=session.player.data.mcoin, + hcoin=session.player.data.hcoin, + scoin=session.player.data.scoin, + world_level=session.player.data.world_level, + ) + ) + except: + traceback.print_exc() \ No newline at end of file diff --git a/game_server/handlers/PlayerLoginFinishCsReq.py b/game_server/handlers/PlayerLoginFinishCsReq.py new file mode 100644 index 0000000..e250220 --- /dev/null +++ b/game_server/handlers/PlayerLoginFinishCsReq.py @@ -0,0 +1,28 @@ +import betterproto +from game_server.net.session import PlayerSession +from rail_proto.lib import ( + PlayerLoginFinishCsReq, + PlayerLoginFinishScRsp, + ContentPackageSyncDataScNotify, + ContentPackageData, + ContentPackageInfo, + ContentPackageStatus +) + +async def handle(session: PlayerSession, msg: PlayerLoginFinishCsReq) -> betterproto.Message: + content = [200001,200002,200003,150017,150015] + await session.notify( + ContentPackageSyncDataScNotify( + data=ContentPackageData( + cur_content_id=0, + content_package_list=[ + ContentPackageInfo( + content_id=id, + status=ContentPackageStatus.ContentPackageStatus_Finished.value + ) for id in content + ] + ) + ) + ) + session.active = True + return PlayerLoginFinishScRsp(retcode=0) \ No newline at end of file diff --git a/game_server/handlers/RelicRecommendCsReq.py b/game_server/handlers/RelicRecommendCsReq.py new file mode 100644 index 0000000..c9a6a40 --- /dev/null +++ b/game_server/handlers/RelicRecommendCsReq.py @@ -0,0 +1,12 @@ +import betterproto +from game_server.net.session import PlayerSession +from rail_proto.lib import ( + RelicRecommendCsReq, + RelicRecommendScRsp +) + +async def handle(session: PlayerSession, msg: RelicRecommendCsReq) -> betterproto.Message: + return RelicRecommendScRsp( + retcode=0, + avatar_id=msg.avatar_id + ) \ No newline at end of file diff --git a/game_server/handlers/ReplaceLineupCsReq.py b/game_server/handlers/ReplaceLineupCsReq.py new file mode 100644 index 0000000..669de8a --- /dev/null +++ b/game_server/handlers/ReplaceLineupCsReq.py @@ -0,0 +1,18 @@ +import betterproto +from game_server.net.session import PlayerSession +from rail_proto.lib import ( + ReplaceLineupCsReq, + ReplaceLineupScRsp, + SyncLineupNotify +) + +async def handle(session: PlayerSession, msg: ReplaceLineupCsReq) -> betterproto.Message: + lineup = session.player.lineup_manager.get(msg.index) + lineup.avatar_list = [avatar.id for avatar in msg.lineup_slot_list] + await session.notify( + SyncLineupNotify( + lineup=lineup.ToProto() + ) + ) + #lineup.save_lineup() + return ReplaceLineupScRsp(retcode=0) \ No newline at end of file diff --git a/game_server/handlers/SceneCastSkillCsReq.py b/game_server/handlers/SceneCastSkillCsReq.py new file mode 100644 index 0000000..f7efbb7 --- /dev/null +++ b/game_server/handlers/SceneCastSkillCsReq.py @@ -0,0 +1,63 @@ +import betterproto +from game_server.net.session import PlayerSession +from game_server.resource import ResourceManager +from game_server.resource.configdb.stage_config import StageConfig +from rail_proto.lib import ( + SceneCastSkillCsReq, + SceneCastSkillScRsp, + SceneBattleInfo, + SceneMonsterWave, + SceneMonster +) +import numpy as np + +async def handle(session: PlayerSession, msg: SceneCastSkillCsReq) -> betterproto.Message: + targets = [id for id in msg.assist_monster_entity_id_list if id > 20000 or id < 10] + for monster in msg.assist_monster_entity_info: + targets.extend( + id for id in monster.entity_id_list + if id not in targets and (id > 20000 or id < 10) + ) + if msg.skill_index == 0 and targets: + monster_data: list[StageConfig] = [] + for entity_id in targets: + entity_data = session.player.scene_manager.entities.get(entity_id) + if entity_data: + stage = ResourceManager.instance().find_by_index(StageConfig,entity_data.npc_monster.event_id*10) + if not stage: + stage = ResourceManager.instance().find_by_index(StageConfig,entity_data.npc_monster.event_id) + if stage: + monster_data.append(stage) + session.player.scene_manager.battle_monster.append(entity_data) + if monster_data: + return SceneCastSkillScRsp( + retcode=0, + cast_entity_id=msg.cast_entity_id, + battle_info=SceneBattleInfo( + rounds_limit=0, + world_level=session.player.data.world_level, + logic_random_seed=np.random.randint(1, np.iinfo(np.int32).max, dtype=np.int32), + stage_id=monster_data[0].StageID, + battle_id=1, + battle_avatar_list=[ + session.player.avatar_mananger.get(avatar_id).ToBattleProto(index,session) + for index, avatar_id in enumerate(session.player.lineup_manager.get(session.player.data.cur_lineup, None).avatar_list) + ], + monster_wave_list=[ + SceneMonsterWave( + battle_stage_id=monster_list.StageID, + battle_wave_id=index, + monster_list=[ + SceneMonster( + monster_id=id + ) + for monster_dict in monster_list.MonsterList + for monster, id in monster_dict.items() + if id > 0 + ] + ) + for index,monster_list in enumerate(monster_data) + ] + ) + ) + return SceneCastSkillScRsp(retcode=0) \ No newline at end of file diff --git a/game_server/handlers/SelectChatBubbleCsReq.py b/game_server/handlers/SelectChatBubbleCsReq.py new file mode 100644 index 0000000..a6e0699 --- /dev/null +++ b/game_server/handlers/SelectChatBubbleCsReq.py @@ -0,0 +1,14 @@ +import betterproto +from game_server.net.session import PlayerSession +from rail_proto.lib import ( + SelectChatBubbleCsReq, + SelectChatBubbleScRsp +) + +async def handle(session: PlayerSession, msg: SelectChatBubbleCsReq) -> betterproto.Message: + session.player.data.chat_bubble = msg.bubble_id + #session.player.data.save_player_data() + return SelectChatBubbleScRsp( + retcode=0, + cur_chat_bubble=msg.bubble_id + ) \ No newline at end of file diff --git a/game_server/handlers/SelectPhoneThemeCsReq.py b/game_server/handlers/SelectPhoneThemeCsReq.py new file mode 100644 index 0000000..26ff685 --- /dev/null +++ b/game_server/handlers/SelectPhoneThemeCsReq.py @@ -0,0 +1,14 @@ +import betterproto +from game_server.net.session import PlayerSession +from rail_proto.lib import ( + SelectPhoneThemeCsReq, + SelectPhoneThemeScRsp +) + +async def handle(session: PlayerSession, msg: SelectPhoneThemeCsReq) -> betterproto.Message: + session.player.data.chat_bubble = msg.theme_id + #session.player.data.save_player_data() + return SelectPhoneThemeScRsp( + retcode=0, + cur_phone_theme=msg.theme_id + ) \ No newline at end of file diff --git a/game_server/handlers/SendMsgCsReq.py b/game_server/handlers/SendMsgCsReq.py new file mode 100644 index 0000000..506c145 --- /dev/null +++ b/game_server/handlers/SendMsgCsReq.py @@ -0,0 +1,36 @@ +import betterproto +from game_server.net.session import PlayerSession +from game_server.game.chat.command_handler import handler +from rail_proto.lib import ( + SendMsgCsReq, + SendMsgScRsp, + RevcMsgScNotify, + MsgType, + ChatType +) + +async def handle(session: PlayerSession, msg: SendMsgCsReq) -> betterproto.Message: + if msg.message_type == MsgType.MSG_TYPE_CUSTOM_TEXT: + session.pending_notify( + RevcMsgScNotify( + message_type=MsgType.MSG_TYPE_CUSTOM_TEXT.value, + chat_type=ChatType.CHAT_TYPE_PRIVATE.value, + message_text=msg.message_text, + target_uid=69, + source_uid=session.player.data.uid + ) + ) + text = await handler.handle_command(session, msg.message_text) + if text: + session.pending_notify( + RevcMsgScNotify( + message_type=MsgType.MSG_TYPE_CUSTOM_TEXT.value, + chat_type=ChatType.CHAT_TYPE_PRIVATE.value, + message_text=text, + target_uid=session.player.data.uid, + source_uid=69 + ) + ) + return SendMsgScRsp( + retcode=0 + ) \ No newline at end of file diff --git a/game_server/handlers/SetClientPausedCsReq.py b/game_server/handlers/SetClientPausedCsReq.py new file mode 100644 index 0000000..eb11120 --- /dev/null +++ b/game_server/handlers/SetClientPausedCsReq.py @@ -0,0 +1,12 @@ +import betterproto +from game_server.net.session import PlayerSession +from rail_proto.lib import ( + SetClientPausedCsReq, + SetClientPausedScRsp +) + +async def handle(session: PlayerSession, msg: SetClientPausedCsReq) -> betterproto.Message: + return SetClientPausedScRsp( + retcode=0, + paused=msg.paused + ) \ No newline at end of file diff --git a/game_server/handlers/SetHeadIconCsReq.py b/game_server/handlers/SetHeadIconCsReq.py new file mode 100644 index 0000000..6e9ca9f --- /dev/null +++ b/game_server/handlers/SetHeadIconCsReq.py @@ -0,0 +1,14 @@ +import betterproto +from game_server.net.session import PlayerSession +from rail_proto.lib import ( + SetHeadIconCsReq, + SetHeadIconScRsp +) + +async def handle(session: PlayerSession, msg: SetHeadIconCsReq) -> betterproto.Message: + session.player.data.head_icon = msg.id + #session.player.data.save_player_data() + return SetHeadIconScRsp( + retcode=0, + current_head_icon_id=msg.id + ) \ No newline at end of file diff --git a/game_server/handlers/SetNicknameCsReq.py b/game_server/handlers/SetNicknameCsReq.py new file mode 100644 index 0000000..00e61df --- /dev/null +++ b/game_server/handlers/SetNicknameCsReq.py @@ -0,0 +1,15 @@ +import betterproto +from game_server.net.session import PlayerSession +from rail_proto.lib import ( + SetNicknameCsReq, + SetNicknameScRsp +) + +async def handle(session: PlayerSession, msg: SetNicknameCsReq) -> betterproto.Message: + if msg.is_modify: + session.player.data.name = msg.nickname + await session.notify(session.player.PlayerSyncProto()) + return SetNicknameScRsp( + retcode=0, + is_modify=msg.is_modify + ) \ No newline at end of file diff --git a/game_server/main.py b/game_server/main.py new file mode 100644 index 0000000..afc0b72 --- /dev/null +++ b/game_server/main.py @@ -0,0 +1,12 @@ +import asyncio +from game_server.net.gateway import KCPGateway +from utils.config import Config +from game_server.resource import ResourceManager + +def fn_main(): + try: + ResourceManager.instance().load_resources() + asyncio.run(KCPGateway.new(Config.GameServer.IP,Config.GameServer.Port)) + except Exception as e: + print(f"Error: {e}") + diff --git a/game_server/net/gateway.py b/game_server/net/gateway.py new file mode 100644 index 0000000..beb261b --- /dev/null +++ b/game_server/net/gateway.py @@ -0,0 +1,143 @@ +import asyncio +from nazo_rand import randrange +from game_server.net.kcp import get_conv +from game_server.net.packet import NetOperation +from game_server.net.session import PlayerSession +from utils.logger import Info,Warn,Debug +from database.mongodb import get_database + + +class KCPGateway(asyncio.DatagramProtocol): + def __init__(self, db): + self.id_counter = 0 + self.sessions : dict[int, PlayerSession] = {} + self.running = True + self.shutdown_event = asyncio.Event() + self.db = db + self.timeout_check_interval = 5 + self.save_duration = 60 + + async def check_sessions_timeout(self): + while self.running: + for conv_id, session in list(self.sessions.items()): + if session.is_timeout(): + self.drop_kcp_session(conv_id) + await asyncio.sleep(self.timeout_check_interval) + + async def periodic_save_sessions(self): + while self.running: + start = asyncio.get_event_loop().time() + + for session in self.sessions.values(): + session.player.save_all() + + elapsed = asyncio.get_event_loop().time() - start + Info(f"Database saved in {elapsed:.2f}s") + + await asyncio.sleep(self.save_duration) + + def connection_made(self, transport): + self.transport = transport + Info(f"Listening on {self.transport.get_extra_info('sockname')}") + + asyncio.create_task(self.check_sessions_timeout()) + asyncio.create_task(self.periodic_save_sessions()) + + def datagram_received(self, data, addr): + data_len = len(data) + + Debug(f"Received {data_len} bytes from {addr}: {[b for b in data]}") + + if data_len == 20: + self.process_net_operation(NetOperation.from_bytes(data), addr) + elif data_len >= 28: + self.process_kcp_payload(data, addr) + else: + Warn("Unknown data length received") + + def process_net_operation(self, op: NetOperation, addr): + if (op.head, op.tail) == (0xFF, 0xFFFFFFFF): + self.establish_kcp_session(op.data, addr) + elif (op.head, op.tail) == (0x194, 0x19419494): + self.drop_kcp_session(op.conv_id) + else: + Warn(f"Unknown magic pair: {op.head}-{op.tail}") + + def establish_kcp_session(self, data, addr): + conv_id, session_token = self.next_conv_pair() + session_id = conv_id << 32 | session_token + + Info(f"New connection: {addr} with conv_id: {conv_id}") + + self.sessions[conv_id] = PlayerSession( + self.transport, session_id, addr, self.db + ) + + net_op = NetOperation( + head=0x145, + conv_id=conv_id, + session_token=session_token, + data=data, + tail=0x14514545, + ).to_bytes() + + self.transport.sendto(net_op, addr) + + def drop_kcp_session(self, conv_id): + if conv_id in self.sessions: + self.sessions[conv_id].player.save_all() + del self.sessions[conv_id] + Info(f"Dropped KCP session with conv_id: {conv_id}") + else: + Warn( + f"Attempted to drop non-existent KCP session with conv_id: {conv_id}" + ) + + def process_kcp_payload(self, data, addr): + conv_id = get_conv(data) + session = self.sessions.get(conv_id) + + if session: + session.update_last_received() + asyncio.create_task(session.consume(data)) + else: + Warn(f"Received data for unknown session conv_id: {conv_id}") + + def next_conv_pair(self): + self.id_counter += 1 + return self.id_counter, randrange(0, 0xFF) + + def connection_lost(self, exc): + Info("UDP connection lost, shutting down...") + + for session in self.sessions.values(): + session.player.save_all() + + self.running = False + self.shutdown_event.set() + + def shutdown(self): + Info("Shutting down server...") + + for session in self.sessions.values(): + session.player.save_all() + + self.running = False + self.shutdown_event.set() + + @staticmethod + async def new(host, port): + loop = asyncio.get_running_loop() + db = get_database() + + transport, protocol = await loop.create_datagram_endpoint( + lambda: KCPGateway(db), local_addr=(host, port) + ) + + try: + await protocol.shutdown_event.wait() + except asyncio.CancelledError: + Info("Server tasks cancelled.") + finally: + transport.close() + Info("Server stopped.") diff --git a/game_server/net/kcp.py b/game_server/net/kcp.py new file mode 100644 index 0000000..0ec9725 --- /dev/null +++ b/game_server/net/kcp.py @@ -0,0 +1,657 @@ +import struct +from collections import deque +from typing import Callable + +# thanks mero for this kcp lib :3 +# this file is excluded from the CC0-1.0 License +# this file is licensed under GPL-3.0 from the author written below + +__version__ = "1.0.0" +__author__ = "Mero " + + +IKCP_RTO_NDL = 30 +IKCP_RTO_MIN = 100 +IKCP_RTO_DEF = 200 +IKCP_RTO_MAX = 60000 +IKCP_CMD_PUSH = 81 +IKCP_CMD_ACK = 82 +IKCP_CMD_WASK = 83 +IKCP_CMD_WINS = 84 +IKCP_ASK_SEND = 1 +IKCP_ASK_TELL = 2 +IKCP_WND_SND = 32 +IKCP_WND_RCV = 128 +IKCP_MTU_DEF = 1400 +IKCP_ACK_FAST = 3 +IKCP_INTERVAL = 100 +IKCP_DEADLINK = 20 +IKCP_THRESH_INIT = 2 +IKCP_THRESH_MIN = 2 +IKCP_PROBE_INIT = 7000 +IKCP_PROBE_LIMIT = 120000 +IKCP_FASTACK_LIMIT = 5 + +IKCP_PACKET_HEAD_FORMAT = " int: + assert len(buf) >= IKCP_OVERHEAD + return struct.unpack_from(" None: + self.data = b"" + + self.resendts = 0 + self.rto = 0 + self.fastack = 0 + self.xmit = 0 + + def parse(self, data): + conv, token, cmd, frg, wnd, ts, sn, una, len = struct.unpack( + IKCP_PACKET_HEAD_FORMAT, data[:IKCP_OVERHEAD] + ) + + self.session_id = conv << 32 | token + self.cmd = cmd + self.frg = frg + self.wnd = wnd + + self.ts = ts + self.sn = sn + self.una = una + self.data = data[IKCP_OVERHEAD : IKCP_OVERHEAD + len] + + return IKCP_OVERHEAD + len + + def encode(self) -> bytes: + conv = self.session_id >> 32 + token = self.session_id & 0xFFFFFFFF + + return ( + struct.pack( + IKCP_PACKET_HEAD_FORMAT, + conv, + token, + self.cmd, + self.frg, + self.wnd, + int(self.ts), + self.sn, + self.una, + int(len(self.data)), + ) + + self.data + ) + + +class Kcp: + __slots__ = ( + "session_id", + "current", + "rx_srtt", + "rx_rttval", + "snd_wnd", + "interval", + "rx_minrto", + "snd_nxt", + "rmt_wnd", + "snd_buf", + "snd_una", + "snd_queue", + "updated", + "ts_flush", + "xmit", + "state", + "ts_probe", + "probe_wait", + "use_fastask_conserve", + "rcv_nxt", + "rcv_wnd", + "rcv_buf", + "rcv_queue", + "probe", + "acklist", + "cwnd", + "mtu", + "mss", + "ssthresh", + "incr", + "rx_rto", + "stream", + "output", + "nodelay", + "nocwnd", + "dead_link", + "fastresend", + "fastlimit", + ) + + def __init__(self, session_id: int, output: Callable[[bytes], None]): + assert session_id < 1 << 64 + + self.use_fastask_conserve = False + self.session_id = session_id + self.output = output + + self.snd_una = 0 + self.snd_nxt = 0 + self.rcv_nxt = 0 + + self.ts_probe = 0 + self.probe_wait = 0 + + self.snd_wnd = IKCP_WND_SND + self.rcv_wnd = IKCP_WND_RCV + self.rmt_wnd = IKCP_WND_RCV + + self.cwnd = 0 + self.incr = 0 + self.probe = 0 + + self.mtu = IKCP_MTU_DEF + self.mss = self.mtu - IKCP_OVERHEAD + self.stream = False + + self.snd_buf = deque() + self.rcv_buf = deque() + self.rcv_queue = deque() + self.snd_queue = deque() + + self.state = 0 + self.acklist = deque() + + self.rx_srtt = 0 + self.rx_rttval = 0 + self.rx_rto = IKCP_RTO_DEF + self.rx_minrto = IKCP_RTO_MIN + + self.current = 0 + self.interval = IKCP_INTERVAL + self.ts_flush = IKCP_INTERVAL + self.nodelay = 0 + self.updated = False + + self.ssthresh = IKCP_THRESH_INIT + self.fastresend = 0 + self.fastlimit = IKCP_FASTACK_LIMIT + self.nocwnd = False + self.xmit = 0 + self.dead_link = IKCP_DEADLINK + + def parse_una(self, una): + while self.snd_buf: + seg = self.snd_buf[0] + + if seg.sn >= una: + break + + self.snd_buf.popleft() + + def shrink_buf(self): + self.snd_una = self.snd_buf[0].sn if self.snd_buf else self.snd_nxt + + def update_ack(self, rtt): + if self.rx_srtt == 0: + self.rx_srtt = rtt + self.rx_rttval = rtt // 2 + else: + delta = abs(rtt - self.rx_srtt) + self.rx_rttval = (3 * self.rx_rttval + delta) // 4 + self.rx_srtt = max((7 * self.rx_srtt + rtt) // 8, 1) + + rto = self.rx_srtt + max(self.interval, 4 * self.rx_rttval) + self.rx_rto = min(max(self.rx_minrto, rto), IKCP_RTO_MAX) + + def parse_ack(self, sn): + if self.snd_una > sn or self.snd_nxt <= sn: + return + + for seg in self.snd_buf: + if sn == seg.sn: + self.snd_buf.remove(seg) + break + + if seg.sn > sn: + break + + def move_buf(self): + while self.rcv_buf: + seg = self.rcv_buf[0] + if seg.sn != self.rcv_nxt or len(self.rcv_queue) >= self.rcv_wnd: + break + + self.rcv_nxt += 1 + self.rcv_queue.append(self.rcv_buf.popleft()) + + def parse_data(self, newseg): + if (self.rcv_nxt + self.rcv_wnd) <= newseg.sn or self.rcv_nxt > newseg.sn: + return + + repeat = False + new_index = len(self.rcv_buf) + + for seg in reversed(self.rcv_buf): + if seg.sn == newseg.sn: + repeat = True + break + + if seg.sn < newseg.sn: + break + + new_index -= 1 + + if not repeat: + self.rcv_buf.insert(new_index, newseg) + + self.move_buf() + + def parse_fastack(self, sn, ts): + if self.snd_una > sn or self.snd_nxt <= sn: + return + + for seg in self.snd_buf: + if seg.sn > sn: + break + elif sn != seg.sn and (self.use_fastask_conserve or seg.ts <= ts): + seg.fastack += 1 + + def input(self, data: bytes): + if not data or len(data) < IKCP_OVERHEAD: + raise KcpException(f"data size must be greater than {IKCP_OVERHEAD}") + + maxack = 0 + latest_ts = 0 + flag = False + prev_una = self.snd_una + + while len(data) >= IKCP_OVERHEAD: + seg = KcpSegment() + data = data[seg.parse(data) :] + + if seg.session_id != self.session_id: + raise KcpException( + f"wrong session id, got {seg.session_id} but {self.session_id} was expected" + ) + + if seg.cmd not in ( + IKCP_CMD_PUSH, + IKCP_CMD_ACK, + IKCP_CMD_WASK, + IKCP_CMD_WINS, + ): + raise KcpException(f"unknown kcp cmd {seg.cmd}") + + self.rmt_wnd = seg.wnd + + self.parse_una(seg.una) + self.shrink_buf() + + if seg.cmd == IKCP_CMD_ACK: + rtt = self.current - seg.ts + if rtt >= 0: + self.update_ack(rtt) + + self.parse_ack(seg.sn) + self.shrink_buf() + + if not flag: + flag = True + maxack = seg.sn + latest_ts = seg.ts + elif maxack < seg.sn and ( + self.use_fastask_conserve or latest_ts > seg.ts + ): + maxack = seg.sn + latest_ts = seg.ts + + elif seg.cmd == IKCP_CMD_PUSH: + if self.rcv_nxt + self.rcv_wnd > seg.sn: + self.acklist.append((seg.sn, seg.ts)) + if self.rcv_nxt <= seg.sn: + self.parse_data(seg) + + elif seg.cmd == IKCP_CMD_WASK: + self.probe |= IKCP_ASK_TELL + + if flag: + self.parse_fastack(maxack, latest_ts) + + if self.snd_una - prev_una > 0 and self.cwnd < self.rmt_wnd: + mss = self.mss + if self.cwnd < self.ssthresh: + self.cwnd += 1 + self.incr += mss + else: + if self.incr < mss: + self.incr = mss + self.incr += mss * mss // self.incr + mss // 16 + if (self.cwnd + 1) * mss <= self.incr: + self.cwnd = (self.incr + mss - 1) // mss if mss > 0 else 1 + if self.cwnd > self.rmt_wnd: + self.cwnd = self.rmt_wnd + self.incr = self.rmt_wnd * mss + + def peeksize(self): + if not self.rcv_queue: + return -1 + + seg = self.rcv_queue[0] + if seg.frg == 0: + return len(seg.data) + if len(self.rcv_queue) < seg.frg + 1: + return -1 + + length = 0 + for seg in self.rcv_queue: + length += len(seg.data) + if seg.frg == 0: + break + + return length + + def recv(self) -> bytes | None: + if not self.rcv_queue: + return None + + peeksize = self.peeksize() + if peeksize < 0: + return None + + recover = len(self.rcv_queue) >= self.rcv_wnd + data = b"" + + while seg := self.rcv_queue.popleft(): + data += seg.data + if seg.frg == 0: + break + + assert len(data) == peeksize + self.move_buf() + + if len(self.rcv_queue) < self.rcv_wnd and recover: + self.probe |= IKCP_ASK_TELL + + return data + + def send(self, data: bytes): + assert self.mss > 0 + + if self.stream: + if self.snd_queue: + seg = self.snd_queue[-1] + if len(seg.data) < self.mss: + capacity = self.mss - len(seg.data) + extend = min(len(data), capacity) + + seg.data += data[:extend] + data = data[extend:] + seg.frg = 0 + + if not data: + return + + count = (len(data) + self.mss - 1) // self.mss if len(data) > self.mss else 1 + if count >= IKCP_WND_RCV: + raise KcpException("user buffer is too long") + count = max(count, 1) + + for i in range(count): + size = min(self.mss, len(data)) + + newseg = KcpSegment() + newseg.data = data[:size] + newseg.frg = 0 if self.stream else count - i - 1 + + data = data[size:] + self.snd_queue.append(newseg) + + def update(self, current: int): + assert current < 1 << 32 + self.current = current + + if not self.updated: + self.updated = True + self.ts_flush = self.current + + slap = self.current - self.ts_flush + + if slap >= 10000 or slap < -10000: + self.ts_flush = self.current + slap = 0 + + if slap >= 0: + self.ts_flush += self.interval + if self.ts_flush <= self.current: + self.ts_flush = self.current + self.interval + self.flush() + + def wnd_unused(self): + return max(self.rcv_wnd - len(self.rcv_queue), 0) + + def flush(self): + if not self.updated: + return + + seg = KcpSegment() + seg.session_id = self.session_id + seg.cmd = IKCP_CMD_ACK + seg.frg = 0 + seg.wnd = self.wnd_unused() + seg.una = self.rcv_nxt + seg.sn = 0 + seg.ts = 0 + + data = b"" + for sn, ts in self.acklist: + if len(data) + IKCP_OVERHEAD > self.mtu: + self.output(data) + data = b"" + seg.sn = sn + seg.ts = ts + data += seg.encode() + self.acklist.clear() + + if self.rmt_wnd == 0: + if self.probe_wait == 0: + self.probe_wait = IKCP_PROBE_INIT + self.ts_probe = self.current + self.probe_wait + elif self.ts_probe <= self.current: + self.probe_wait = min( + self.probe_wait + max(self.probe_wait, IKCP_PROBE_INIT) // 2, + IKCP_PROBE_LIMIT, + ) + self.ts_probe = self.current + self.probe_wait + self.probe |= IKCP_ASK_SEND + else: + self.ts_probe = 0 + self.probe_wait = 0 + + if self.probe & IKCP_ASK_SEND: + seg.cmd = IKCP_CMD_WASK + if len(data) + IKCP_OVERHEAD > self.mtu: + self.output(data) + data = b"" + data += seg.encode() + + if self.probe & IKCP_ASK_TELL: + seg.cmd = IKCP_CMD_WINS + if len(data) + IKCP_OVERHEAD > self.mtu: + self.output(data) + data = b"" + data += seg.encode() + + self.probe = 0 + + cwnd = min(self.snd_wnd, self.rmt_wnd) + if not self.nocwnd: + cwnd = min(self.cwnd, cwnd) + + while self.snd_una + cwnd > self.snd_nxt: + if not self.snd_queue: + break + + newseg = self.snd_queue.popleft() + self.snd_buf.append(newseg) + + newseg.session_id = self.session_id + newseg.cmd = IKCP_CMD_PUSH + newseg.wnd = seg.wnd + newseg.ts = self.current + + newseg.sn = self.snd_nxt + self.snd_nxt += 1 + + newseg.una = self.rcv_nxt + newseg.resendts = self.current + newseg.rto = self.rx_rto + newseg.fastack = 0 + newseg.xmit = 0 + + resent = 0xFFFFFFFF + if self.fastresend > 0: + resent = self.fastresend + + rtomin = 0 + if not self.nodelay: + rtomin = self.rx_rto >> 3 + + lost = False + change = False + + for segment in self.snd_buf: + needsend = False + + if segment.xmit == 0: + needsend = True + segment.xmit += 1 + segment.rto = self.rx_rto + segment.resendts = self.current + segment.rto + rtomin + elif segment.resendts <= self.current: + needsend = True + segment.xmit += 1 + self.xmit += 1 + if not self.nodelay: + segment.rto += max(segment.rto, self.rx_rto) + else: + step = segment.rto if self.nodelay < 2 else self.rx_rto + segment.rto += step // 2 + segment.resendts = self.current + segment.rto + lost = True + elif segment.fastack >= resent and ( + segment.xmit <= self.fastlimit or self.fastlimit <= 0 + ): + needsend = True + segment.xmit += 1 + segment.fastack = 0 + segment.resendts = self.current + segment.rto + change = True + + if needsend: + segment.ts = self.current + segment.wnd = seg.wnd + segment.una = self.rcv_nxt + + if len(data) + IKCP_OVERHEAD + len(segment.data) > self.mtu: + self.output(data) + data = b"" + + data += segment.encode() + if segment.xmit >= self.dead_link: + self.state = -1 + + if data: + self.output(data) + + if change: + inflight = self.snd_nxt - self.snd_una + self.ssthresh = max(inflight // 2, IKCP_THRESH_MIN) + self.cwnd = self.ssthresh + resent + self.incr = self.cwnd * self.mss + + if lost: + self.ssthresh = max(cwnd // 2, IKCP_THRESH_MIN) + self.cwnd = 1 + self.incr = self.mss + + if self.cwnd < 1: + self.cwnd = 1 + self.incr = self.mss + + def check(self, current): + assert current < 1 << 32 + + ts_flush = self.ts_flush + tm_packet = 0x7FFFFFFF + + if not self.updated: + return current + + if current - self.ts_flush >= 10000 or current - self.ts_flush < -10000: + ts_flush = current + + if ts_flush <= current: + return current + + tm_flush = ts_flush - current + + for seg in self.snd_buf: + diff = seg.resendts - current + if diff <= 0: + return current + if diff < tm_packet: + tm_packet = diff + + return current + min(tm_flush, tm_packet, self.interval) + + def set_mtu(self, mtu: int): + if mtu < 50 or mtu < IKCP_OVERHEAD: + raise KcpException("invalid mtu") + + self.mtu = mtu + self.mss = self.mtu - IKCP_OVERHEAD + + def set_nodelay(self, nodelay: int, interval: int, resend: int, nc: int): + if nodelay >= 0: + self.nodelay = nodelay + if nodelay: + self.rx_minrto = IKCP_RTO_NDL + else: + self.rx_minrto = IKCP_RTO_MIN + + if interval >= 0: + self.interval = min(max(10, interval), 5000) + + if resend >= 0: + self.fastresend = resend + + if nc >= 0: + self.nocwnd = nc + + def set_wndsize(self, sndwnd: int, rcvwnd: int): + if sndwnd > 0: + self.snd_wnd = sndwnd + if rcvwnd > 0: + self.rcv_wnd = max(rcvwnd, IKCP_WND_RCV) diff --git a/game_server/net/packet.py b/game_server/net/packet.py new file mode 100644 index 0000000..a25a72c --- /dev/null +++ b/game_server/net/packet.py @@ -0,0 +1,93 @@ +from dataclasses import dataclass +import struct + +HEAD_MAGIC = 0x9D74C714 +TAIL_MAGIC = 0xD7A152C8 + + +@dataclass +class NetPacket: + cmd_type: int + head: bytes + body: bytes + + def to_message(self, m) -> "NetPacket": + return m.parse(self.body) + + @staticmethod + def from_message(c, m) -> "NetPacket": + return NetPacket(cmd_type=c, head=[], body=bytes(m)) + + def to_bytes(self) -> bytes: + # packet_length = 12 + len(self.head) + len(self.body) + 4 + b = bytearray() + + b.extend(struct.pack(">I", HEAD_MAGIC)) + b.extend(struct.pack(">H", self.cmd_type)) + b.extend(struct.pack(">H", len(self.head))) + b.extend(struct.pack(">I", len(self.body))) + b.extend(self.head) + b.extend(self.body) + b.extend(struct.pack(">I", TAIL_MAGIC)) + + return bytes(b) + + @staticmethod + def from_bytes(b: bytes) -> "NetPacket": + if len(b) < 16: + raise ValueError("len(b) < 16") + + head_magic = struct.unpack_from(">I", b, 0)[0] + + if head_magic != HEAD_MAGIC: + raise ValueError("Invalid head magic") + + cmd_type = struct.unpack_from(">H", b, 4)[0] + head_length = struct.unpack_from(">H", b, 6)[0] + body_length = struct.unpack_from(">I", b, 8)[0] + + head_start = 12 + head_end = head_start + head_length + + if head_end > len(b): + raise ValueError("Head data > packet length") + + head = b[head_start:head_end] + + body_start = head_end + body_end = body_start + body_length + + if body_end + 4 > len(b): + raise ValueError("Body data > packet length") + + body = b[body_start:body_end] + + tail_magic = struct.unpack_from(">I", b, body_end)[0] + + if tail_magic != TAIL_MAGIC: + raise ValueError("Invalid tail magic") + + return NetPacket(cmd_type, head, body) + + +@dataclass +class NetOperation: + head: int + conv_id: int + session_token: int + data: int + tail: int + + def to_bytes(self) -> bytes: + return struct.pack( + ">IIIII", self.head, self.conv_id, self.session_token, self.data, self.tail + ) + + @staticmethod + def from_bytes(b: bytes) -> "NetOperation": + if len(b) != 20: + raise ValueError("len(b) != 20") + + head, conv_id, session_token, data, tail = struct.unpack(">IIIII", b) + + return NetOperation(head, conv_id, session_token, data, tail) diff --git a/game_server/net/session.py b/game_server/net/session.py new file mode 100644 index 0000000..41533f8 --- /dev/null +++ b/game_server/net/session.py @@ -0,0 +1,133 @@ +import asyncio +import importlib +import betterproto +from game_server.net.kcp import Kcp +from game_server.net.packet import NetPacket +from utils.logger import Info,Error,Warn +from rail_proto import cmd +from rail_proto import lib as protos +from game_server.game.player.player_manager import PlayerManager +from game_server.dummy import dummyprotolist +import traceback + +class PlayerSession: + def __init__(self, transport, session_id, client_addr, db): + self.transport = transport + self.session_id = session_id + self.client_addr = client_addr + self.kcp = Kcp(session_id, self.send_output) + self.kcp.set_nodelay(1, 5, 2, 0) + self.is_destroyed = False + self.db = db + self.pending_notifies = list() + self.player = PlayerManager() + self.active = False + self.last_received = asyncio.get_event_loop().time() + + def update_last_received(self): + self.last_received = asyncio.get_event_loop().time() + + def is_timeout(self, timeout=15): + return asyncio.get_event_loop().time() - self.last_received > timeout + + def pending_notify(self, data: betterproto.Message, delay=0): + """ + This can be used to queue packet to be sent after response inside a handler + """ + self.pending_notifies.append((data, delay)) + + async def notify(self, data: betterproto.Message): + msg_name = data.__class__.__name__ + cmd_id = getattr(cmd.CmdID, msg_name, None) + if not cmd_id: + Warn(f"Server tried to send notify with unsupported message: {msg_name}") + return + + response_packet = NetPacket.from_message(cmd_id, data) + await self.send(response_packet) + + def send_output(self, data): + self.transport.sendto(data, self.client_addr) + + async def consume(self, data): + self.kcp.input(data) + self.kcp.update(asyncio.get_running_loop().time()) + + while True: + packet = self.kcp.recv() + if packet is None: + break + await self.handle_packet(packet) + + self.kcp.update(asyncio.get_running_loop().time()) + + async def handle_packet(self, packet): + net_packet = NetPacket.from_bytes(packet) + cmd_id = net_packet.cmd_type + + request_name = cmd.get_key_by_value(cmd_id) + if not request_name: + Warn( + f"Request doesn't have registered message_id: {cmd_id}" + ) + return + if request_name[:-5] in dummyprotolist: + dummy_cmd_id = getattr(cmd.CmdID, f"{request_name[:-5]}ScRsp", None) + dummy_response = NetPacket.from_message(dummy_cmd_id, b'') + await self.send(dummy_response) + return + try: + try: + req: betterproto.Message = getattr(protos, request_name)() + req.parse(net_packet.body) + except Exception: + req = betterproto.Message() + + try: + handle_result: betterproto.Message = await importlib.import_module( + f"game_server.handlers.{request_name}" + ).handle(self, req) + if not handle_result: + return + except ModuleNotFoundError: + Error(f"Unhandled request {request_name}") + return + except Exception: + Error(f"Handler {request_name} returns error.") + traceback.print_exc() + return + + Info(f"Received cmd: {request_name}({cmd_id})") + + response_name = handle_result.__class__.__name__ + cmd_type = getattr(cmd.CmdID, response_name, None) + if not cmd_type: + Warn( + f"Server tried to send response with unsupported message: {response_name}" + ) + return + response_packet = NetPacket.from_message(cmd_type, handle_result) + await self.send(response_packet) + + + asyncio.create_task(self.send_pending_notifies( + self.pending_notifies.copy() + )) + + self.pending_notifies.clear() + except: + pass + + async def send_pending_notifies( + self, + pending_notifies: list[tuple[betterproto.Message, int]] + ): + for notify, delay in pending_notifies: + if delay > 0: + await asyncio.sleep(delay) + await self.notify(notify) + + async def send(self, packet): + self.kcp.send(packet.to_bytes()) + self.kcp.flush() + self.kcp.update(asyncio.get_running_loop().time()) diff --git a/game_server/resource/__init__.py b/game_server/resource/__init__.py new file mode 100644 index 0000000..549170e --- /dev/null +++ b/game_server/resource/__init__.py @@ -0,0 +1,79 @@ +import json +import traceback +from typing import Dict, Type, TypeVar, Optional, Any, List + +from utils.logger import Error, Info +from game_server.resource.base_resource import BaseResource +from game_server.resource.decorators import resource_registry +import game_server.resource.configdb # noqa: F401 + +T = TypeVar("T", bound=BaseResource) + + +def filter_data(cls: Type, data): + valid_fields = cls.__annotations__.keys() + return {field: data.get(field, None) for field in valid_fields} + + +class ResourceManager: + def __init__(self): + self.data: Dict[Type[T], Dict[Any, T]] = {} + self.check_floor: bool = False + + def load_resources(self) -> None: + Info("[BOOT] [ResourceManager] Loading Resourcses...") + sorted_load_priority = dict( + sorted(resource_registry.items(), key=lambda item: item[1]["load_priority"]) + ).items() + for cls, metadata in sorted_load_priority: + path = metadata["path"] + try: + with open(path, "r", encoding="utf-8") as file: + raw_data = json.load(file) + except Exception: + Error(f"Error when loading resource {path}") + traceback.print_exc() + continue + + self.data[cls] = {} + i = 0 + for data in raw_data: + data = filter_data(cls, data) + item: T = cls(**data) + if "MapEntrance" in path: + if not self.check_floor: + Info("[BOOT] Loading floor infos... this may take a while.") + self.check_floor = True + if not item.check_floor_dir(): + break + if not item.on_load(): + continue + i += 1 + index_value = item.get_index() + + if index_value not in self.data[cls]: + self.data[cls][index_value] = [] + self.data[cls][index_value].append(item) + Info(f"[BOOT] [ResourceManager] Loaded {i} config(s) for {cls.__name__}") + if "MapEntrance" in path: + Info(f"[BOOT] Loaded floor infos.") + + def find_by_index(self, cls: Type[T], value: Any) -> Optional[T]: + items = self.data.get(cls, {}).get(str(value), []) + return items[0] if items else None + + def find_all_by_index(self, cls: Type[T], value: Any) -> List[T]: + return self.data.get(cls, {}).get(str(value), []) + + def has_index(self, cls: Type[T], value: Any) -> bool: + return str(value) in self.data.get(cls, {}) + + def values(self, cls: Type[T]) -> List[T]: + return [item for sublist in self.data.get(cls, {}).values() for item in sublist] + + @staticmethod + def instance(): + return resource_manager + + +resource_manager = ResourceManager() diff --git a/game_server/resource/base_resource.py b/game_server/resource/base_resource.py new file mode 100644 index 0000000..4556795 --- /dev/null +++ b/game_server/resource/base_resource.py @@ -0,0 +1,19 @@ +from abc import ABC, abstractmethod +from dataclasses import dataclass +from typing import TypeVar + +T = TypeVar("T", bound="BaseResource") + +@dataclass +class BaseResource(ABC): + def on_load(self: T) -> bool: + """returns True by default if item loaded, otherwise will be skipped""" + return True + + def check_floor_dir(self: T) -> bool: + """returns True by default if floor dir exist, otherwise will be skipped""" + return True + + @abstractmethod + def get_index(self) -> str: + pass diff --git a/game_server/resource/configdb/__init__.py b/game_server/resource/configdb/__init__.py new file mode 100644 index 0000000..85f20e3 --- /dev/null +++ b/game_server/resource/configdb/__init__.py @@ -0,0 +1,15 @@ +import importlib +import os +import sys + +folder = "game_server/resource/configdb" +sys.path.append(os.path.dirname(folder)) + +for filename in os.listdir(folder): + if filename.endswith(".py") and filename != "__init__.py": + module_name = filename[:-3] + module_path = f"game_server.resource.configdb.{module_name}" + try: + importlib.import_module(module_path) + except Exception as e: + print(f"Error importing module '{module_path}': {e}") diff --git a/game_server/resource/configdb/avatar_config.py b/game_server/resource/configdb/avatar_config.py new file mode 100644 index 0000000..720415b --- /dev/null +++ b/game_server/resource/configdb/avatar_config.py @@ -0,0 +1,32 @@ +from dataclasses import dataclass, field +from game_server.resource.base_resource import BaseResource, T +from game_server.resource.decorators import GameResource +from game_server.resource.configdb.avatar_skill_tree_config import AvatarSkillTreeConfig + +@dataclass +@GameResource("resources/ExcelOutput/AvatarConfig.json") +class AvatarConfig(BaseResource): + AvatarID: int + AvatarSkills: dict[int, int] + + def on_load(self: T) -> bool: + from game_server.resource import ResourceManager + + self.AvatarSkills = {} + + skill_tree_config = ResourceManager.instance().find_all_by_index( + AvatarSkillTreeConfig, self.AvatarID + ) + + for skill in skill_tree_config: + skill_id = skill.PointID + skill_level = skill.MaxLevel + + skill = self.AvatarSkills.get(skill_id) + if not skill: + self.AvatarSkills[skill_id] = skill_level + return True + + + def get_index(self) -> str: + return str(self.AvatarID) diff --git a/game_server/resource/configdb/avatar_skill_tree_config.py b/game_server/resource/configdb/avatar_skill_tree_config.py new file mode 100644 index 0000000..d09f27f --- /dev/null +++ b/game_server/resource/configdb/avatar_skill_tree_config.py @@ -0,0 +1,13 @@ +from dataclasses import dataclass +from game_server.resource.base_resource import BaseResource +from game_server.resource.decorators import GameResource, LoadPriority + +@dataclass +@GameResource("resources/ExcelOutput/AvatarSkillTreeConfig.json", load_priority=LoadPriority.HIGH) +class AvatarSkillTreeConfig(BaseResource): + AvatarID: int + MaxLevel: int + PointID: int + + def get_index(self) -> str: + return str(self.AvatarID) diff --git a/game_server/resource/configdb/challenge_maze_config.py b/game_server/resource/configdb/challenge_maze_config.py new file mode 100644 index 0000000..7503069 --- /dev/null +++ b/game_server/resource/configdb/challenge_maze_config.py @@ -0,0 +1,22 @@ +from dataclasses import dataclass +from game_server.resource.base_resource import BaseResource +from game_server.resource.decorators import GameResource + +@dataclass +@GameResource("resources/ExcelOutput/ChallengeMazeConfig.json") +class ChallengeMazeConfig(BaseResource): + ID: int + MazeBuffID: int + ChallengeCountDown: int + MapEntranceID: int + MapEntranceID2: int + MazeGroupID1: int + MazeGroupID2: int + GroupID: int + EventIDList1: list + EventIDList2: list + NpcMonsterIDList1: list + NpcMonsterIDList2: list + + def get_index(self) -> str: + return str(self.ID) diff --git a/game_server/resource/configdb/equipment_config.py b/game_server/resource/configdb/equipment_config.py new file mode 100644 index 0000000..6e30d1e --- /dev/null +++ b/game_server/resource/configdb/equipment_config.py @@ -0,0 +1,12 @@ + +from dataclasses import dataclass +from game_server.resource.base_resource import BaseResource +from game_server.resource.decorators import GameResource + +@dataclass +@GameResource("resources/ExcelOutput/EquipmentConfig.json") +class EquipmentConfig(BaseResource): + EquipmentID: int + + def get_index(self) -> str: + return str(self.EquipmentID) diff --git a/game_server/resource/configdb/item_config.py b/game_server/resource/configdb/item_config.py new file mode 100644 index 0000000..7889d7b --- /dev/null +++ b/game_server/resource/configdb/item_config.py @@ -0,0 +1,13 @@ + +from dataclasses import dataclass +from game_server.resource.base_resource import BaseResource +from game_server.resource.decorators import GameResource + +@dataclass +@GameResource("resources/ExcelOutput/ItemConfig.json") +class ItemConfig(BaseResource): + ID: int + ItemSubType: str + + def get_index(self) -> str: + return str(self.ID) diff --git a/game_server/resource/configdb/main_mission.py b/game_server/resource/configdb/main_mission.py new file mode 100644 index 0000000..adb245f --- /dev/null +++ b/game_server/resource/configdb/main_mission.py @@ -0,0 +1,11 @@ +from dataclasses import dataclass +from game_server.resource.base_resource import BaseResource +from game_server.resource.decorators import GameResource + +@dataclass +@GameResource("resources/ExcelOutput/MainMission.json") +class MainMissionData(BaseResource): + MainMissionID: int + + def get_index(self) -> str: + return str(self.MainMissionID) diff --git a/game_server/resource/configdb/map_default_entrance.py b/game_server/resource/configdb/map_default_entrance.py new file mode 100644 index 0000000..3a1df96 --- /dev/null +++ b/game_server/resource/configdb/map_default_entrance.py @@ -0,0 +1,12 @@ +from dataclasses import dataclass +from game_server.resource.base_resource import BaseResource +from game_server.resource.decorators import GameResource + +@dataclass +@GameResource("resources/ExcelOutput/MapDefaultEntrance.json") +class MapDefaultEntranceData(BaseResource): + EntranceID: int + FloorID: int + + def get_index(self) -> str: + return str(self.FloorID) diff --git a/game_server/resource/configdb/map_entrance.py b/game_server/resource/configdb/map_entrance.py new file mode 100644 index 0000000..0fd469e --- /dev/null +++ b/game_server/resource/configdb/map_entrance.py @@ -0,0 +1,85 @@ +import os +import json +import dataclasses +from utils.logger import Warn +from game_server.resource.base_resource import BaseResource +from game_server.resource.decorators import GameResource,LoadPriority +from game_server.resource.configdb.sub_type.floor_info import FloorInfo,parse_floor_info +from game_server.resource.configdb.sub_type.group_info import parse_group_info + +floor_dir = './resources/Config/LevelOutput/RuntimeFloor/' + +@dataclasses.dataclass +@GameResource("resources/ExcelOutput/MapEntrance.json", load_priority=LoadPriority.LOW) +class MapEntranceData(BaseResource): + ID: int + PlaneID: int + FloorID: int + StartAnchorID: int + StartGroupID: int + EntranceType: str + + floor_infos: dict[int, FloorInfo] = dataclasses.field(default_factory=dict) + + def on_load(self) -> bool: + name = f"P{self.PlaneID}_F{self.FloorID}" + file_path = os.path.join(floor_dir, f"{name}.json") + if not os.path.exists(file_path): + Warn(f"Missing floor info: {name}") + return False + + with open(file_path, 'r', encoding='utf-8') as file: + raw_data = json.load(file) + + self.floor_infos = {} + + floor_data = parse_floor_info(raw_data) + self.floor_infos[self.ID] = floor_data + + floor = self.floor_infos[self.ID] + + for simpleGroup in floor.GroupInstanceList: + if simpleGroup.IsDelete: + continue + + group_file_path = os.path.join('./resources/', simpleGroup.GroupPath) + + if not os.path.exists(group_file_path): + Warn(f"Missing GroupPath info: {simpleGroup.GroupPath}") + continue + + try: + with open(group_file_path, 'r', encoding='utf-8') as group_file: + content = group_file.read().strip() + if not content: + Warn(f"File is empty: {group_file_path}") + continue + + group_raw_data = json.loads(content) + + except json.JSONDecodeError as e: + Warn(f"Error decoding JSON in file {group_file_path}: {e}") + continue + + except Exception as e: + Warn(f"Unexpected error occurred while processing file {group_file_path}: {e}") + continue + + group_info = parse_group_info(group_raw_data) + group_info.id = simpleGroup.ID + + if group_info.OwnerMainMissionID and group_info.OwnerMainMissionID > 0: + continue + + floor.groups[simpleGroup.ID] = group_info + + return True + + def check_floor_dir(self) -> bool: + if not os.path.exists(floor_dir): + Warn(f"Floor infos are missing, please check your resources folder: {floor_dir}. Teleports and natural world spawns may not work!") + return + return True + + def get_index(self) -> str: + return str(self.ID) diff --git a/game_server/resource/configdb/maze_plane.py b/game_server/resource/configdb/maze_plane.py new file mode 100644 index 0000000..174802a --- /dev/null +++ b/game_server/resource/configdb/maze_plane.py @@ -0,0 +1,15 @@ +from dataclasses import dataclass +from game_server.resource.base_resource import BaseResource +from game_server.resource.decorators import GameResource +from game_server.game.enums.scene.game_mode_type import GameModeTypeEnum + +@dataclass +@GameResource("resources/ExcelOutput/MazePlane.json") +class MazePlaneData(BaseResource): + PlaneID: int + PlaneType: GameModeTypeEnum + WorldID: int + StartFloorID: int + + def get_index(self) -> str: + return str(self.PlaneID) diff --git a/game_server/resource/configdb/player_icon_config.py b/game_server/resource/configdb/player_icon_config.py new file mode 100644 index 0000000..d91e102 --- /dev/null +++ b/game_server/resource/configdb/player_icon_config.py @@ -0,0 +1,13 @@ + +from dataclasses import dataclass +from game_server.resource.base_resource import BaseResource +from game_server.resource.decorators import GameResource + +@dataclass +@GameResource("resources/ExcelOutput/PlayerIconConfig.json") +class PlayerIconConfig(BaseResource): + ID: int + IsVisible: bool + + def get_index(self) -> str: + return str(self.ID) diff --git a/game_server/resource/configdb/relic_config.py b/game_server/resource/configdb/relic_config.py new file mode 100644 index 0000000..14cb887 --- /dev/null +++ b/game_server/resource/configdb/relic_config.py @@ -0,0 +1,18 @@ +from dataclasses import dataclass +from game_server.resource.base_resource import BaseResource +from game_server.resource.decorators import GameResource + +@dataclass +@GameResource("resources/ExcelOutput/RelicConfig.json") +class RelicConfigData(BaseResource): + ID: int + Type: str + MaxLevel: int + MainAffixGroup: int + SubAffixGroup: int + + def on_load(self) -> bool: + return self.MaxLevel == 15 + + def get_index(self) -> str: + return str(self.ID) diff --git a/game_server/resource/configdb/relic_main_affix_config.py b/game_server/resource/configdb/relic_main_affix_config.py new file mode 100644 index 0000000..7cb0adb --- /dev/null +++ b/game_server/resource/configdb/relic_main_affix_config.py @@ -0,0 +1,15 @@ +from dataclasses import dataclass +from game_server.resource.base_resource import BaseResource +from game_server.resource.decorators import GameResource + +@dataclass +@GameResource("resources/ExcelOutput/RelicMainAffixConfig.json") +class RelicMainAffixConfigData(BaseResource): + GroupID: int + AffixID: int + Property: str + + def get_index(self) -> str: + return str(self.GroupID) + + diff --git a/game_server/resource/configdb/relic_sub_affix_config.py b/game_server/resource/configdb/relic_sub_affix_config.py new file mode 100644 index 0000000..1291533 --- /dev/null +++ b/game_server/resource/configdb/relic_sub_affix_config.py @@ -0,0 +1,16 @@ +from dataclasses import dataclass +from game_server.resource.base_resource import BaseResource +from game_server.resource.decorators import GameResource + +@dataclass +@GameResource("resources/ExcelOutput/RelicSubAffixConfig.json") +class RelicSubAffixConfigData(BaseResource): + GroupID: int + AffixID: int + StepNum: int + Property: str + + def get_index(self) -> str: + return str(self.GroupID) + + diff --git a/game_server/resource/configdb/stage_config.py b/game_server/resource/configdb/stage_config.py new file mode 100644 index 0000000..2549ec8 --- /dev/null +++ b/game_server/resource/configdb/stage_config.py @@ -0,0 +1,15 @@ +from dataclasses import dataclass +from game_server.resource.base_resource import BaseResource +from game_server.resource.decorators import GameResource + +@dataclass +@GameResource("resources/ExcelOutput/StageConfig.json") +class StageConfig(BaseResource): + StageID: int + StageType: str + MonsterList: list + + def get_index(self) -> str: + return str(self.StageID) + + diff --git a/game_server/resource/configdb/sub_type/anchor_info.py b/game_server/resource/configdb/sub_type/anchor_info.py new file mode 100644 index 0000000..2a0c430 --- /dev/null +++ b/game_server/resource/configdb/sub_type/anchor_info.py @@ -0,0 +1,12 @@ +import dataclasses + +@dataclasses.dataclass +class AnchorInfo: + ID: int + Name : str + PosX : float + PosY : float + PosZ : float + RotX : float + RotY : float + RotZ : float \ No newline at end of file diff --git a/game_server/resource/configdb/sub_type/floor_info.py b/game_server/resource/configdb/sub_type/floor_info.py new file mode 100644 index 0000000..2a0ed89 --- /dev/null +++ b/game_server/resource/configdb/sub_type/floor_info.py @@ -0,0 +1,35 @@ +import dataclasses +from typing import List, Optional, Dict +from game_server.resource.configdb.sub_type.group_info import GroupInfo + +@dataclasses.dataclass +class GroupInstance: + GroupPath: str + ID: int + IsDelete: Optional[bool] = False + +@dataclasses.dataclass +class FloorInfo: + FloorID: int + StartGroupIndex: int + StartAnchorID: int + GroupInstanceList: List[GroupInstance] + groups: Dict[int, GroupInfo] = dataclasses.field(default_factory=dict) + + +def parse_floor_info(raw_data: dict) -> FloorInfo: + group_instances = [ + GroupInstance( + GroupPath=group.get("GroupPath", ""), + ID=group.get("ID", 0), + IsDelete=group.get("IsDelete", False), + ) + for group in raw_data.get("GroupInstanceList", []) + ] + return FloorInfo( + FloorID=raw_data.get("FloorID", 0), + StartGroupIndex=raw_data.get("StartGroupIndex", 0), + StartAnchorID=raw_data.get("StartAnchorID", 0), + GroupInstanceList=group_instances, + groups={}, + ) \ No newline at end of file diff --git a/game_server/resource/configdb/sub_type/group_info.py b/game_server/resource/configdb/sub_type/group_info.py new file mode 100644 index 0000000..3ddca14 --- /dev/null +++ b/game_server/resource/configdb/sub_type/group_info.py @@ -0,0 +1,89 @@ +import dataclasses +from typing import List, Optional,Type, TypeVar +from enum import Enum +from game_server.resource.configdb.sub_type.npc_info import NpcInfo +from game_server.resource.configdb.sub_type.anchor_info import AnchorInfo +from game_server.resource.configdb.sub_type.monster_info import MonsterInfo +from game_server.resource.configdb.sub_type.prop_info import PropInfo,PropState + +T = TypeVar('T') + +class GroupLoadSide(Enum): + CLIENT = "Client" + SERVER = "Server" + + @classmethod + def from_value(cls, value): + if value in ("Server"): + return cls.SERVER + elif value in ("Client"): + return cls.CLIENT + raise ValueError(f"{value!r} is not a valid GroupLoadSide") + + +@dataclasses.dataclass +class GroupInfo: + NPCList: List[NpcInfo] = dataclasses.field(default_factory=list) + id: Optional[int] = dataclasses.field(default_factory=int) + OwnerMainMissionID: Optional[int] = dataclasses.field(default_factory=int) + LoadOnInitial: Optional[bool] = dataclasses.field(default_factory=bool) + AnchorList: Optional[List[AnchorInfo]] = dataclasses.field(default_factory=list) + MonsterList: Optional[List[MonsterInfo]] = dataclasses.field(default_factory=list) + PropList: Optional[List[PropInfo]] = dataclasses.field(default_factory=list) + LoadSide: Optional[str] = None + + +def parse_dataclass(cls: Type[T], raw_data: dict) -> T: + """ + Parse a dictionary into a dataclass, filtering out unknown fields + and filling in missing fields with default values. + :param cls: The dataclass type to instantiate. + :param raw_data: The raw dictionary data. + :return: An instance of the dataclass. + """ + cls_fields = {f.name: f for f in dataclasses.fields(cls)} + filtered_data = {} + + for field_name, field_def in cls_fields.items(): + if field_name in raw_data: + filtered_data[field_name] = raw_data[field_name] + elif field_def.default is not dataclasses.MISSING: + filtered_data[field_name] = field_def.default + elif field_def.default_factory is not dataclasses.MISSING: + filtered_data[field_name] = field_def.default_factory() + else: + if field_def.type == float: + filtered_data[field_name] = 0.0 + elif field_def.type == int: + filtered_data[field_name] = 0 + elif field_def.type == str: + filtered_data[field_name] = "" + elif field_def.type == list: + filtered_data[field_name] = [] + elif field_def.type == dict: + filtered_data[field_name] = {} + else: + filtered_data[field_name] = None + + return cls(**filtered_data) + +def parse_group_info(raw_data: dict) -> GroupInfo: + def parse_state(state): + return PropState[state].value + + return GroupInfo( + id=raw_data.get("id"), + OwnerMainMissionID=raw_data.get("OwnerMainMissionID"), + LoadOnInitial=raw_data.get("LoadOnInitial", False), + NPCList=[parse_dataclass(NpcInfo, npc) for npc in (raw_data.get("NPCList") or [])], + AnchorList=[parse_dataclass(AnchorInfo, anchor) for anchor in (raw_data.get("AnchorList") or [])], + MonsterList=[parse_dataclass(MonsterInfo, monster) for monster in (raw_data.get("MonsterList") or [])], + PropList=[ + parse_dataclass( + PropInfo, + {k: (parse_state(v) if k == "State" else v) for k, v in prop.items()} + ) + for prop in (raw_data.get("PropList") or []) + ], + LoadSide=raw_data.get("LoadSide") if raw_data.get("LoadSide") else None, + ) \ No newline at end of file diff --git a/game_server/resource/configdb/sub_type/monster_info.py b/game_server/resource/configdb/sub_type/monster_info.py new file mode 100644 index 0000000..60f547e --- /dev/null +++ b/game_server/resource/configdb/sub_type/monster_info.py @@ -0,0 +1,15 @@ +import dataclasses + +@dataclasses.dataclass +class MonsterInfo: + ID : int + NPCMonsterID : int + EventID : int + FarmElementID : int + IsClientOnly : bool + PosX : float + PosY : float + PosZ : float + RotX : float + RotY : float + RotZ : float \ No newline at end of file diff --git a/game_server/resource/configdb/sub_type/npc_info.py b/game_server/resource/configdb/sub_type/npc_info.py new file mode 100644 index 0000000..e8c55a4 --- /dev/null +++ b/game_server/resource/configdb/sub_type/npc_info.py @@ -0,0 +1,13 @@ +import dataclasses + +@dataclasses.dataclass +class NpcInfo: + ID : int + NPCID : int + IsClientOnly: bool + PosX : float + PosY : float + PosZ : float + RotX : float + RotY : float + RotZ : float \ No newline at end of file diff --git a/game_server/resource/configdb/sub_type/prop_info.py b/game_server/resource/configdb/sub_type/prop_info.py new file mode 100644 index 0000000..7998376 --- /dev/null +++ b/game_server/resource/configdb/sub_type/prop_info.py @@ -0,0 +1,65 @@ +from typing import List, Optional +import dataclasses +from enum import Enum + +class PropState(Enum): + Closed = 0 + Open = 1 + Locked = 2 + BridgeState1 = 3 + BridgeState2 = 4 + BridgeState3 = 5 + BridgeState4 = 6 + CheckPointDisable = 7 + CheckPointEnable = 8 + TriggerDisable = 9 + TriggerEnable = 10 + ChestLocked = 11 + ChestClosed = 12 + ChestUsed = 13 + Elevator1 = 14 + Elevator2 = 15 + Elevator3 = 16 + WaitActive = 17 + EventClose = 18 + EventOpen = 19 + Hidden = 20 + TeleportGate0 = 21 + TeleportGate1 = 22 + TeleportGate2 = 23 + TeleportGate3 = 24 + Destructed = 25 + CustomState01 = 101 + CustomState02 = 102 + CustomState03 = 103 + CustomState04 = 104 + CustomState05 = 105 + CustomState06 = 106 + CustomState07 = 107 + CustomState08 = 108 + CustomState09 = 109 + +@dataclasses.dataclass +class ValueSource: + Values: Optional[List] = dataclasses.field(default_factory=list) + +@dataclasses.dataclass +class PropInfo: + ID : int + MappingInfoID : int + AnchorGroupID : int + AnchorID : int + PropID : int + EventID : int + CocoonID : int + FarmElementID : int + IsClientOnly : int + State: PropState + PosX : float + PosY : float + PosZ : float + RotX : float + RotY : float + RotZ : float + IsDelete: bool + Name : str \ No newline at end of file diff --git a/game_server/resource/decorators.py b/game_server/resource/decorators.py new file mode 100644 index 0000000..63437fa --- /dev/null +++ b/game_server/resource/decorators.py @@ -0,0 +1,17 @@ +from typing import Type, Dict + +resource_registry: Dict[Type, Dict[str, any]] = {} + + +class LoadPriority: + HIGH = 1 + NORMAL = 2 + LOW = 3 + + +def GameResource(path: str, load_priority=LoadPriority.NORMAL): + def decorator(cls): + resource_registry[cls] = {"path": path, "load_priority": load_priority} + return cls + + return decorator diff --git a/gameserver b/gameserver new file mode 100644 index 0000000..eaff809 --- /dev/null +++ b/gameserver @@ -0,0 +1,3 @@ +from game_server.main import fn_main + +fn_main() \ No newline at end of file diff --git a/rail_proto/cmd.py b/rail_proto/cmd.py new file mode 100644 index 0000000..7dca4e1 --- /dev/null +++ b/rail_proto/cmd.py @@ -0,0 +1,1896 @@ +from enum import IntEnum + +class CmdID(IntEnum): + TakeTrialActivityRewardCsReq = 2634 + AvatarDeliverRewardChooseAvatarCsReq = 2617 + GetActivityScheduleConfigScRsp = 2648 + StartTrialActivityCsReq = 2601 + GetTrialActivityDataCsReq = 2654 + EnterTrialActivityStageScRsp = 2635 + GetActivityScheduleConfigCsReq = 2676 + LeaveTrialActivityCsReq = 2636 + TakeMaterialSubmitActivityRewardCsReq = 2642 + GetAvatarDeliverRewardActivityDataScRsp = 2690 + SubmitMaterialSubmitActivityMaterialScRsp = 2633 + TakeLoginActivityRewardCsReq = 2631 + TakeMaterialSubmitActivityRewardScRsp = 2677 + GetTrialActivityDataScRsp = 2699 + AvatarDeliverRewardTakeRewardCsReq = 2649 + SubmitMaterialSubmitActivityMaterialCsReq = 2643 + GetMaterialSubmitActivityDataScRsp = 2639 + StartTrialActivityScRsp = 2653 + TakeLoginActivityRewardScRsp = 2640 + AvatarDeliverRewardTakeRewardScRsp = 2603 + LeaveTrialActivityScRsp = 2694 + AvatarDeliverRewardChooseAvatarScRsp = 2669 + GetLoginActivityScRsp = 2632 + TrialActivityDataChangeScNotify = 2687 + TakeTrialActivityRewardScRsp = 2668 + GetAvatarDeliverRewardActivityDataCsReq = 2674 + GetMaterialSubmitActivityDataCsReq = 2602 + EnterTrialActivityStageCsReq = 2608 + GetLoginActivityCsReq = 2695 + CurTrialActivityScNotify = 2627 + QuickStartFarmElementCsReq = 1371 + QuickStartFarmElementScRsp = 1352 + FarmElementSweepCsReq = 1372 + CocoonSweepCsReq = 1322 + EnterAdventureScRsp = 1332 + EnterAdventureCsReq = 1395 + CocoonSweepScRsp = 1356 + QuickStartCocoonStageCsReq = 1376 + FarmElementSweepScRsp = 1385 + GetFarmStageGachaInfoCsReq = 1331 + GetFarmStageGachaInfoScRsp = 1340 + QuickStartCocoonStageScRsp = 1348 + AetherDivideTakeChallengeRewardScRsp = 4808 + AetherDivideSpiritInfoScNotify = 4818 + ClearAetherDividePassiveSkillScRsp = 4823 + AetherDivideSkillItemScNotify = 4811 + AetherDivideTakeChallengeRewardCsReq = 4814 + GetAetherDivideInfoScRsp = 4807 + StartAetherDivideStageBattleScRsp = 4842 + AetherDivideLineupScNotify = 4813 + EquipAetherDividePassiveSkillCsReq = 4820 + LeaveAetherDivideSceneCsReq = 4802 + SwitchAetherDivideLineUpSlotScRsp = 4822 + AetherDivideRefreshEndlessScNotify = 4849 + StartAetherDivideChallengeBattleScRsp = 4815 + SetAetherDivideLineUpCsReq = 4850 + GetAetherDivideChallengeInfoScRsp = 4805 + AetherDivideTainerInfoScNotify = 4839 + LeaveAetherDivideSceneScRsp = 4837 + EnterAetherDivideSceneCsReq = 4804 + EnterAetherDivideSceneScRsp = 4846 + GetAetherDivideChallengeInfoCsReq = 4801 + StartAetherDivideChallengeBattleCsReq = 4827 + AetherDivideSpiritExpUpCsReq = 4829 + AetherDivideRefreshEndlessScRsp = 4821 + SetAetherDivideLineUpScRsp = 4840 + AetherDivideFinishChallengeScNotify = 4835 + EquipAetherDividePassiveSkillScRsp = 4844 + StartAetherDivideSceneBattleScRsp = 4817 + ClearAetherDividePassiveSkillCsReq = 4832 + AetherDivideSpiritExpUpScRsp = 4834 + SwitchAetherDivideLineUpSlotCsReq = 4826 + GetAetherDivideInfoCsReq = 4845 + StartAetherDivideSceneBattleCsReq = 4836 + AetherDivideRefreshEndlessCsReq = 4806 + StartAetherDivideStageBattleCsReq = 4816 + AlleyShipUsedCountScNotify = 4737 + AlleyTakeEventRewardCsReq = 4751 + LogisticsGameScRsp = 4740 + LogisticsDetonateStarSkiffCsReq = 4724 + AlleyPlacingGameCsReq = 4716 + AlleyTakeEventRewardScRsp = 4791 + TakePrestigeRewardCsReq = 4772 + GetSaveLogisticsMapCsReq = 4714 + LogisticsGameCsReq = 4731 + SaveLogisticsCsReq = 4763 + PrestigeLevelUpScRsp = 4777 + AlleyShipmentEventEffectsScNotify = 4725 + PrestigeLevelUpCsReq = 4742 + RefreshAlleyOrderScRsp = 4739 + AlleyGuaranteedFundsScRsp = 4775 + ActivityRaidPlacingGameCsReq = 4798 + RefreshAlleyOrderCsReq = 4702 + LogisticsScoreRewardSyncInfoScNotify = 4707 + LogisticsDetonateStarSkiffScRsp = 4757 + GetAlleyInfoScRsp = 4732 + AlleyPlacingGameScRsp = 4746 + GetAlleyInfoCsReq = 4795 + StartAlleyEventScRsp = 4752 + TakePrestigeRewardScRsp = 4785 + AlleyEventEffectNotify = 4756 + AlleyShopLevelScNotify = 4721 + AlleyOrderChangedScNotify = 4743 + SaveLogisticsScRsp = 4711 + AlleyShipUnlockScNotify = 4729 + AlleyFundsScNotify = 4758 + StartAlleyEventCsReq = 4771 + LogisticsInfoScNotify = 4793 + GetSaveLogisticsMapScRsp = 4784 + AlleyEventChangeNotify = 4722 + ActivityRaidPlacingGameScRsp = 4764 + AlleyGuaranteedFundsCsReq = 4730 + GetArchiveDataCsReq = 2395 + GetUpdatedArchiveDataScRsp = 2340 + GetArchiveDataScRsp = 2332 + GetUpdatedArchiveDataCsReq = 2331 + AvatarExpUpScRsp = 340 + TakeOffAvatarSkinCsReq = 321 + TakeOffEquipmentScRsp = 385 + DressAvatarSkinScRsp = 358 + TakePromotionRewardCsReq = 333 + AddAvatarScNotify = 316 + MarkAvatarCsReq = 311 + UnlockSkilltreeCsReq = 376 + PromoteAvatarCsReq = 371 + GetPreAvatarGrowthInfoScRsp = 375 + DressAvatarSkinCsReq = 377 + DressRelicAvatarScRsp = 302 + RankUpAvatarCsReq = 346 + TakeOffEquipmentCsReq = 372 + GetAvatarDataScRsp = 332 + DressAvatarScRsp = 356 + DressRelicAvatarCsReq = 360 + UnlockAvatarSkinScNotify = 363 + PromoteAvatarScRsp = 352 + SetGrowthTargetAvatarScRsp = 384 + AvatarExpUpCsReq = 331 + AddMultiPathAvatarScNotify = 325 + RankUpAvatarScRsp = 383 + SetGrowthTargetAvatarCsReq = 314 + TakeOffRelicCsReq = 339 + DressAvatarCsReq = 322 + TakePromotionRewardScRsp = 342 + TakeOffRelicScRsp = 343 + GrowthTargetAvatarChangedScNotify = 337 + GetAvatarDataCsReq = 395 + GetPreAvatarGrowthInfoCsReq = 330 + TakeOffAvatarSkinScRsp = 329 + MarkAvatarScRsp = 393 + GetPreAvatarListCsReq = 351 + UnlockSkilltreeScRsp = 348 + GetPreAvatarListScRsp = 391 + PVEBattleResultCsReq = 195 + PVEBattleResultScRsp = 132 + SyncClientResVersionCsReq = 171 + BattleLogReportScRsp = 172 + QuitBattleScRsp = 140 + BattleLogReportCsReq = 156 + QuitBattleScNotify = 122 + GetCurBattleInfoScRsp = 148 + GetCurBattleInfoCsReq = 176 + ReBattleAfterBattleLoseCsNotify = 116 + QuitBattleCsReq = 131 + ServerSimulateBattleFinishScNotify = 185 + RebattleByClientCsNotify = 146 + SyncClientResVersionScRsp = 152 + GetBattleCollegeDataCsReq = 5795 + StartBattleCollegeCsReq = 5740 + BattleCollegeDataChangeScNotify = 5731 + GetBattleCollegeDataScRsp = 5732 + StartBattleCollegeScRsp = 5776 + TakeBpRewardCsReq = 3040 + TakeAllRewardScRsp = 3022 + TakeBpRewardScRsp = 3076 + BattlePassInfoNotify = 3095 + BuyBpLevelScRsp = 3071 + BuyBpLevelCsReq = 3048 + TakeAllRewardCsReq = 3052 + TakeBenefitActivityRewardCsReq = 4852 + GetBenefitActivityInfoScRsp = 4896 + JoinBenefitActivityScRsp = 4867 + JoinBenefitActivityCsReq = 4886 + GetBenefitActivityInfoCsReq = 4854 + TakeBenefitActivityRewardScRsp = 4887 + StartBoxingClubBattleScRsp = 4248 + SetBoxingClubResonanceLineupScRsp = 4246 + SetBoxingClubResonanceLineupCsReq = 4216 + BoxingClubChallengeUpdateScNotify = 4256 + GiveUpBoxingClubChallengeScRsp = 4252 + GiveUpBoxingClubChallengeCsReq = 4271 + ChooseBoxingClubResonanceCsReq = 4272 + ChooseBoxingClubResonanceScRsp = 4285 + BoxingClubRewardScNotify = 4222 + GetBoxingClubInfoCsReq = 4295 + StartBoxingClubBattleCsReq = 4276 + MatchBoxingClubOpponentCsReq = 4231 + ChooseBoxingClubStageOptionalBuffCsReq = 4283 + GetBoxingClubInfoScRsp = 4232 + ChooseBoxingClubStageOptionalBuffScRsp = 4260 + MatchBoxingClubOpponentScRsp = 4240 + LeaveChallengeCsReq = 1776 + TakeChallengeRewardScRsp = 1760 + RestartChallengePhaseScRsp = 1758 + StartPartialChallengeScRsp = 1733 + StartChallengeScRsp = 1740 + GetChallengeGroupStatisticsScRsp = 1739 + TakeChallengeRewardCsReq = 1783 + EnterChallengeNextPhaseCsReq = 1721 + GetChallengeScRsp = 1732 + ChallengeLineupNotify = 1785 + LeaveChallengeScRsp = 1748 + GetCurChallengeCsReq = 1756 + StartChallengeCsReq = 1731 + GetChallengeCsReq = 1795 + EnterChallengeNextPhaseScRsp = 1729 + ChallengeBossPhaseSettleNotify = 1763 + RestartChallengePhaseCsReq = 1777 + StartPartialChallengeCsReq = 1743 + GetChallengeGroupStatisticsCsReq = 1702 + GetCurChallengeScRsp = 1772 + ChallengeSettleNotify = 1771 + SendMsgScRsp = 3932 + GetLoginChatInfoScRsp = 3960 + GetPrivateChatHistoryCsReq = 3976 + BatchMarkChatEmojiCsReq = 3916 + RevcMsgScNotify = 3931 + MarkChatEmojiCsReq = 3972 + GetLoginChatInfoCsReq = 3983 + BatchMarkChatEmojiScRsp = 3946 + SendMsgCsReq = 3995 + GetChatEmojiListScRsp = 3956 + PrivateMsgOfflineUsersScNotify = 3940 + GetChatFriendHistoryCsReq = 3971 + MarkChatEmojiScRsp = 3985 + GetChatEmojiListCsReq = 3922 + GetPrivateChatHistoryScRsp = 3948 + GetChatFriendHistoryScRsp = 3952 + ChessRogueUpdateDiceInfoScNotify = 5514 + ChessRoguePickAvatarScRsp = 5568 + ChessRogueQueryAeonDimensionsCsReq = 5578 + SelectChessRogueSubStoryScRsp = 5496 + ChessRogueCheatRollScRsp = 5473 + ChessRogueSelectCellScRsp = 5422 + SyncChessRogueNousValueScNotify = 5506 + ChessRogueNousEnableRogueTalentScRsp = 5523 + ChessRogueRollDiceScRsp = 5426 + GetChessRogueNousStoryInfoScRsp = 5594 + FinishChessRogueSubStoryScRsp = 5504 + ChessRogueNousEditDiceCsReq = 5571 + ChessRogueUpdateReviveInfoScNotify = 5598 + ChessRogueNousGetRogueTalentInfoCsReq = 5505 + EnhanceChessRogueBuffScRsp = 5419 + ChessRogueRollDiceCsReq = 5533 + SyncChessRogueMainStoryFinishScNotify = 5477 + ChessRogueEnterNextLayerScRsp = 5501 + EnhanceChessRogueBuffCsReq = 5551 + FinishChessRogueSubStoryCsReq = 5520 + ChessRogueChangeyAeonDimensionNotify = 5486 + ChessRogueLeaveCsReq = 5573 + SyncChessRogueNousSubStoryScNotify = 5497 + ChessRogueQueryScRsp = 5447 + SelectChessRogueSubStoryCsReq = 5535 + GetChessRogueStoryInfoScRsp = 5481 + ChessRogueUpdateBoardScNotify = 5580 + ChessRogueNousGetRogueTalentInfoScRsp = 5552 + ChessRogueLayerAccountInfoNotify = 5555 + ChessRogueStartCsReq = 5471 + ChessRogueNousEnableRogueTalentCsReq = 5433 + EnterChessRogueAeonRoomCsReq = 5585 + ChessRogueNousDiceUpdateNotify = 5597 + ChessRogueUpdateAeonModifierValueScNotify = 5574 + ChessRogueQuestFinishNotify = 5526 + GetChessRogueStoryInfoCsReq = 5570 + ChessRogueReRollDiceScRsp = 5445 + ChessRogueEnterCellScRsp = 5518 + ChessRogueQueryAeonDimensionsScRsp = 5413 + ChessRogueReRollDiceCsReq = 5587 + ChessRogueUpdateDicePassiveAccumulateValueScNotify = 5415 + ChessRogueUpdateActionPointScNotify = 5468 + GetChessRogueBuffEnhanceInfoScRsp = 5586 + ChessRogueNousDiceSurfaceUnlockNotify = 5538 + ChessRoguePickAvatarCsReq = 5590 + ChessRogueStartScRsp = 5441 + GetChessRogueStoryAeonTalkInfoCsReq = 5588 + ChessRogueGiveUpRollCsReq = 5547 + ChessRogueConfirmRollCsReq = 5448 + ChessRogueReviveAvatarScRsp = 5516 + ChessRogueEnterNextLayerCsReq = 5460 + ChessRogueUpdateLevelBaseInfoScNotify = 5461 + ChessRogueReviveAvatarCsReq = 5465 + GetChessRogueNousStoryInfoCsReq = 5474 + ChessRogueSkipTeachingLevelCsReq = 5418 + ChessRogueUpdateUnlockLevelScNotify = 5527 + ChessRogueQuitCsReq = 5492 + ChessRogueQueryCsReq = 5595 + ChessRogueQuitScRsp = 5521 + ChessRogueGiveUpCsReq = 5529 + ChessRogueGiveUpScRsp = 5436 + ChessRogueCellUpdateNotify = 5490 + EnterChessRogueAeonRoomScRsp = 5417 + ChessRogueEnterScRsp = 5457 + ChessRogueUpdateMoneyInfoScNotify = 5484 + GetChessRogueBuffEnhanceInfoCsReq = 5525 + ChessRogueSelectCellCsReq = 5528 + SyncChessRogueNousMainStoryScNotify = 5510 + ChessRogueConfirmRollScRsp = 5542 + ChessRogueEnterCsReq = 5414 + ChessRogueSkipTeachingLevelScRsp = 5600 + GetChessRogueStoryAeonTalkInfoScRsp = 5449 + ChessRogueUpdateAllowedSelectCellScNotify = 5495 + ChessRogueLeaveScRsp = 5531 + ChessRogueGiveUpRollScRsp = 5408 + ChessRogueCheatRollCsReq = 5512 + ChessRogueEnterCellCsReq = 5472 + ChessRogueNousEditDiceScRsp = 5557 + ChimeraQuitEndlessCsReq = 8165 + ChimeraRoundWorkStartScRsp = 8166 + ChimeraDoFinalRoundCsReq = 8171 + ChimeraSetLineupScRsp = 8170 + ChimeraFinishEndlessRoundScRsp = 8163 + ChimeraFinishRoundScRsp = 8162 + ChimeraFinishEndlessRoundCsReq = 8167 + ChimeraStartEndlessScRsp = 8169 + ChimeraRoundWorkStartCsReq = 8172 + ChimeraGetDataCsReq = 8174 + ChimeraQuitEndlessScRsp = 8161 + ChimeraDoFinalRoundScRsp = 8179 + ChimeraGetDataScRsp = 8173 + ChimeraFinishRoundCsReq = 8164 + ChimeraSetLineupCsReq = 8168 + ChimeraStartEndlessCsReq = 8180 + ClockParkHandleWaitOperationScRsp = 7207 + ClockParkUnlockTalentScRsp = 7217 + ClockParkGetOngoingScriptInfoScRsp = 7209 + ClockParkStartScriptScRsp = 7215 + ClockParkGetInfoCsReq = 7204 + ClockParkFinishScriptScNotify = 7216 + ClockParkGetInfoScRsp = 7246 + ClockParkBattleEndScNotify = 7232 + ClockParkUnlockTalentCsReq = 7236 + ClockParkUseBuffScRsp = 7222 + ClockParkStartScriptCsReq = 7227 + ClockParkGetOngoingScriptInfoCsReq = 7243 + ClockParkUseBuffCsReq = 7226 + ClockParkQuitScriptScRsp = 7240 + ClockParkHandleWaitOperationCsReq = 7245 + ClockParkQuitScriptCsReq = 7250 + ContentPackageUnlockCsReq = 7537 + ContentPackageTransferScNotify = 7517 + ContentPackageSyncDataScNotify = 7502 + ContentPackageUnlockScRsp = 7536 + ContentPackageGetDataScRsp = 7546 + ContentPackageGetDataCsReq = 7504 + TakeAllApRewardCsReq = 3348 + TakeAllApRewardScRsp = 3371 + GetDailyActiveInfoScRsp = 3340 + TakeApRewardCsReq = 3395 + DailyActiveInfoNotify = 3376 + TakeApRewardScRsp = 3332 + GetDailyActiveInfoCsReq = 3331 + ServerLogScNotify = 2486 + GetServerLogSettingsCsReq = 2454 + GetServerGraphDataCsReq = 2467 + UpdateServerLogSettingsCsReq = 2452 + UpdateServerLogSettingsScRsp = 2487 + GetServerLogSettingsScRsp = 2496 + GetServerGraphDataScRsp = 2477 + EndDrinkMakerSequenceCsReq = 6984 + DrinkMakerDayEndScNotify = 6987 + MakeMissionDrinkScRsp = 6989 + MakeDrinkScRsp = 6990 + DrinkMakerUpdateTipsNotify = 6981 + DrinkMakerChallengeCsReq = 6983 + MakeDrinkCsReq = 6988 + GetDrinkMakerDataCsReq = 6994 + EndDrinkMakerSequenceScRsp = 6982 + GetDrinkMakerDataScRsp = 6993 + MakeMissionDrinkCsReq = 7000 + DrinkMakerChallengeScRsp = 6985 + ResetEraFlipperDataScRsp = 6551 + EraFlipperDataChangeScNotify = 6554 + EnterEraFlipperRegionScRsp = 6558 + ChangeEraFlipperDataScRsp = 6569 + ResetEraFlipperDataCsReq = 6574 + GetEraFlipperDataCsReq = 6561 + EnterEraFlipperRegionCsReq = 6553 + ChangeEraFlipperDataCsReq = 6559 + GetEraFlipperDataScRsp = 6570 + EvolveBuildCoinNotify = 7134 + EvolveBuildTakeExpRewardScRsp = 7116 + EvolveBuildSkipTeachLevelCsReq = 7101 + EvolveBuildReRandomStageScRsp = 7150 + EvolveBuildShopAbilityResetScRsp = 7129 + EvolveBuildLeaveCsReq = 7143 + EvolveBuildQueryInfoScRsp = 7146 + EvolveBuildFinishScNotify = 7145 + EvolveBuildTakeExpRewardCsReq = 7122 + EvolveBuildStartLevelScRsp = 7137 + EvolveBuildStartStageCsReq = 7136 + EvolveBuildGiveupScRsp = 7115 + EvolveBuildShopAbilityDownScRsp = 7126 + EvolveBuildSkipTeachLevelScRsp = 7105 + EvolveBuildReRandomStageCsReq = 7107 + EvolveBuildStartLevelCsReq = 7102 + EvolveBuildStartStageScRsp = 7117 + EvolveBuildLeaveScRsp = 7109 + EvolveBuildQueryInfoCsReq = 7104 + EvolveBuildShopAbilityResetCsReq = 7142 + EvolveBuildShopAbilityUpScRsp = 7132 + EvolveBuildShopAbilityUpCsReq = 7144 + EvolveBuildGiveupCsReq = 7127 + EvolveBuildShopAbilityDownCsReq = 7123 + TakeExpeditionRewardCsReq = 2571 + TakeMultipleActivityExpeditionRewardCsReq = 2533 + GetExpeditionDataCsReq = 2595 + TakeMultipleExpeditionRewardCsReq = 2539 + AcceptMultipleExpeditionScRsp = 2502 + AcceptExpeditionScRsp = 2540 + AcceptActivityExpeditionScRsp = 2572 + CancelExpeditionScRsp = 2548 + AcceptActivityExpeditionCsReq = 2556 + TakeExpeditionRewardScRsp = 2552 + CancelExpeditionCsReq = 2576 + TakeActivityExpeditionRewardScRsp = 2583 + CancelActivityExpeditionScRsp = 2516 + AcceptExpeditionCsReq = 2531 + ExpeditionDataChangeScNotify = 2522 + CancelActivityExpeditionCsReq = 2585 + AcceptMultipleExpeditionCsReq = 2560 + TakeMultipleExpeditionRewardScRsp = 2543 + TakeMultipleActivityExpeditionRewardScRsp = 2542 + GetExpeditionDataScRsp = 2532 + TakeActivityExpeditionRewardCsReq = 2546 + FinishChapterScNotify = 4931 + GetFantasticStoryActivityDataScRsp = 4932 + GetFantasticStoryActivityDataCsReq = 4995 + EnterFantasticStoryActivityStageScRsp = 4976 + EnterFantasticStoryActivityStageCsReq = 4940 + FantasticStoryActivityBattleEndScNotify = 4948 + GetFeverTimeActivityDataScRsp = 7151 + EnterFeverTimeActivityStageScRsp = 7155 + EnterFeverTimeActivityStageCsReq = 7152 + GetFeverTimeActivityDataCsReq = 7157 + FeverTimeActivityBattleEndScNotify = 7154 + FightEnterCsReq = 30095 + FightKickOutScNotify = 30040 + FightHeartBeatScRsp = 30048 + FightSessionStopScNotify = 30071 + FightEnterScRsp = 30032 + FightLeaveScNotify = 30031 + FightHeartBeatCsReq = 30076 + FightGeneralScRsp = 30022 + FightGeneralScNotify = 30056 + FightGeneralCsReq = 30052 + EnterFightActivityStageScRsp = 3676 + FightActivityDataChangeScNotify = 3631 + GetFightActivityDataCsReq = 3695 + TakeFightActivityRewardScRsp = 3671 + GetFightActivityDataScRsp = 3632 + EnterFightActivityStageCsReq = 3640 + TakeFightActivityRewardCsReq = 3648 + StartFightFestScRsp = 7287 + StartFightFestCsReq = 7252 + FightFestUpdateCoinNotify = 7265 + GetFightFestDataScRsp = 7296 + FightFestScoreUpdateNotify = 7286 + FightFestUnlockSkillNotify = 7267 + FightFestUpdateChallengeRecordNotify = 7277 + GetFightFestDataCsReq = 7254 + FightMatch3SwapScRsp = 30171 + FightMatch3TurnStartScNotify = 30140 + FightMatch3DataScRsp = 30132 + FightMatch3DataCsReq = 30195 + FightMatch3ChatScNotify = 30172 + FightMatch3ChatScRsp = 30156 + FightMatch3ChatCsReq = 30122 + FightMatch3TurnEndScNotify = 30176 + FightMatch3ForceUpdateNotify = 30185 + FightMatch3SwapCsReq = 30148 + FightMatch3OpponentDataScNotify = 30152 + FightMatch3StartCountDownScNotify = 30131 + GetPlayerDetailInfoCsReq = 2931 + DeleteBlacklistScRsp = 2963 + GetFriendRecommendLineupCsReq = 2936 + GetAssistHistoryCsReq = 2951 + GetCurAssistScRsp = 2975 + GetFriendBattleRecordDetailCsReq = 2934 + NewAssistHistoryNotify = 2924 + GetFriendRecommendLineupDetailScRsp = 2974 + SearchPlayerCsReq = 2911 + SetFriendRemarkNameScRsp = 2977 + SyncDeleteFriendScNotify = 2983 + SetAssistCsReq = 2984 + SearchPlayerScRsp = 2993 + GetFriendDevelopmentInfoScRsp = 2953 + CurAssistChangedNotify = 2998 + SetFriendRemarkNameCsReq = 2942 + GetFriendAssistListScRsp = 2954 + SetAssistScRsp = 2937 + GetAssistListCsReq = 2925 + DeleteBlacklistCsReq = 2929 + GetFriendChallengeDetailCsReq = 2908 + GetFriendChallengeDetailScRsp = 2935 + HandleFriendCsReq = 2956 + GetFriendRecommendLineupDetailCsReq = 2927 + GetFriendLoginInfoScRsp = 2913 + GetPlayerDetailInfoScRsp = 2940 + GetFriendChallengeLineupCsReq = 2999 + SyncAddBlacklistScNotify = 2939 + GetFriendListInfoCsReq = 2995 + AddBlacklistScRsp = 2902 + GetFriendListInfoScRsp = 2932 + TakeAssistRewardCsReq = 2957 + GetFriendAssistListCsReq = 2909 + ApplyFriendScRsp = 2952 + GetFriendRecommendListInfoCsReq = 2943 + GetCurAssistCsReq = 2930 + GetFriendApplyListInfoCsReq = 2976 + SetFriendMarkCsReq = 2986 + GetFriendRecommendListInfoScRsp = 2933 + GetAssistHistoryScRsp = 2991 + SyncApplyFriendScNotify = 2922 + SetForbidOtherApplyFriendCsReq = 2978 + GetFriendApplyListInfoScRsp = 2948 + GetFriendDevelopmentInfoCsReq = 2901 + GetFriendChallengeLineupScRsp = 2987 + GetFriendBattleRecordDetailScRsp = 2968 + HandleFriendScRsp = 2972 + ReportPlayerScRsp = 2921 + SyncHandleFriendScNotify = 2985 + DeleteFriendScRsp = 2946 + AddBlacklistCsReq = 2960 + ApplyFriendCsReq = 2971 + TakeAssistRewardScRsp = 2907 + SetFriendMarkScRsp = 3000 + GetFriendRecommendLineupScRsp = 2994 + GetPlatformPlayerInfoCsReq = 2964 + DeleteFriendCsReq = 2916 + GetAssistListScRsp = 2914 + ReportPlayerCsReq = 2958 + GetFriendLoginInfoCsReq = 2945 + SetForbidOtherApplyFriendScRsp = 2920 + GetPlatformPlayerInfoScRsp = 2906 + DoGachaCsReq = 1931 + GetGachaCeilingScRsp = 1948 + GetGachaInfoScRsp = 1932 + GachaDecideItemChangeScNotify = 1972 + DoGachaScRsp = 1940 + ExchangeGachaCeilingCsReq = 1971 + GetGachaInfoCsReq = 1995 + ExchangeGachaCeilingScRsp = 1952 + SetGachaDecideItemCsReq = 1922 + GetGachaCeilingCsReq = 1976 + SetGachaDecideItemScRsp = 1956 + ChangeScriptEmotionCsReq = 6331 + FinishEmotionDialoguePerformanceCsReq = 6371 + HeartDialTraceScriptCsReq = 6356 + GetHeartDialInfoCsReq = 6395 + FinishEmotionDialoguePerformanceScRsp = 6352 + HeartDialScriptChangeScNotify = 6322 + GetHeartDialInfoScRsp = 6332 + SubmitEmotionItemCsReq = 6376 + SubmitEmotionItemScRsp = 6348 + HeartDialTraceScriptScRsp = 6372 + ChangeScriptEmotionScRsp = 6340 + HeliobusSelectSkillCsReq = 5860 + HeliobusChallengeUpdateScNotify = 5821 + HeliobusSnsUpdateScNotify = 5872 + HeliobusSnsLikeCsReq = 5871 + HeliobusUnlockSkillScNotify = 5883 + HeliobusSnsCommentScRsp = 5856 + HeliobusEnterBattleCsReq = 5833 + HeliobusActivityDataScRsp = 5832 + HeliobusStartRaidCsReq = 5877 + HeliobusStartRaidScRsp = 5858 + HeliobusLineupUpdateScNotify = 5829 + HeliobusUpgradeLevelScRsp = 5846 + HeliobusSnsReadScRsp = 5840 + HeliobusSnsPostScRsp = 5848 + HeliobusSnsPostCsReq = 5876 + HeliobusSnsLikeScRsp = 5852 + HeliobusSnsCommentCsReq = 5822 + HeliobusSnsReadCsReq = 5831 + HeliobusInfoChangedScNotify = 5885 + HeliobusSelectSkillScRsp = 5802 + HeliobusUpgradeLevelCsReq = 5816 + HeliobusActivityDataCsReq = 5895 + HeliobusEnterBattleScRsp = 5842 + ComposeSelectedRelicScRsp = 529 + SellItemScRsp = 533 + GetMarkItemListScRsp = 575 + DeleteRelicFilterPlanCsReq = 535 + BatchRankUpEquipmentScRsp = 517 + GetRelicFilterPlanCsReq = 600 + RelicReforgeConfirmCsReq = 527 + ComposeLimitNumCompleteNotify = 525 + RelicFilterPlanClearNameScNotify = 553 + ComposeSelectedRelicCsReq = 521 + DestroyItemScRsp = 537 + GetBagScRsp = 532 + AddRelicFilterPlanScRsp = 599 + ComposeLimitNumUpdateNotify = 514 + CancelMarkItemNotify = 524 + GetRecyleTimeCsReq = 511 + BatchRankUpEquipmentCsReq = 590 + RechargeSuccNotify = 542 + ModifyRelicFilterPlanCsReq = 587 + DestroyItemCsReq = 584 + LockEquipmentCsReq = 576 + ExpUpRelicScRsp = 560 + GetRecyleTimeScRsp = 593 + GetRelicFilterPlanScRsp = 509 + UseItemCsReq = 571 + MarkItemScRsp = 591 + ExchangeHcoinCsReq = 577 + RelicReforgeCsReq = 536 + LockRelicScRsp = 539 + RankUpEquipmentScRsp = 556 + UseItemScRsp = 552 + LockRelicCsReq = 502 + GetBagCsReq = 595 + SellItemCsReq = 543 + ExpUpEquipmentCsReq = 572 + SetTurnFoodSwitchScRsp = 598 + SyncTurnFoodNotify = 557 + ModifyRelicFilterPlanScRsp = 508 + MarkRelicFilterPlanScRsp = 501 + AddEquipmentScNotify = 563 + ExpUpEquipmentScRsp = 585 + ExchangeHcoinScRsp = 558 + DiscardRelicScRsp = 545 + GeneralVirtualItemDataNotify = 564 + SetTurnFoodSwitchCsReq = 507 + LockEquipmentScRsp = 548 + RelicReforgeScRsp = 594 + MarkItemCsReq = 551 + ComposeItemCsReq = 516 + ExpUpRelicCsReq = 583 + RankUpEquipmentCsReq = 522 + ComposeItemScRsp = 546 + PromoteEquipmentScRsp = 540 + PromoteEquipmentCsReq = 531 + RelicReforgeConfirmScRsp = 574 + MarkRelicFilterPlanCsReq = 568 + DiscardRelicCsReq = 506 + DeleteRelicFilterPlanScRsp = 534 + AddRelicFilterPlanCsReq = 554 + GetMarkItemListCsReq = 530 + PlayBackGroundMusicCsReq = 3131 + GetJukeboxDataScRsp = 3132 + PlayBackGroundMusicScRsp = 3140 + UnlockBackGroundMusicCsReq = 3176 + TrialBackGroundMusicScRsp = 3152 + GetJukeboxDataCsReq = 3195 + UnlockBackGroundMusicScRsp = 3148 + TrialBackGroundMusicCsReq = 3171 + SwapLineupScRsp = 756 + JoinLineupScRsp = 748 + QuitLineupCsReq = 771 + GetStageLineupScRsp = 732 + GetCurLineupDataScRsp = 740 + ExtraLineupDestroyNotify = 729 + GetLineupAvatarDataScRsp = 716 + SwitchLineupIndexScRsp = 702 + GetLineupAvatarDataCsReq = 785 + SwitchLineupIndexCsReq = 760 + GetStageLineupCsReq = 795 + VirtualLineupDestroyNotify = 777 + ReplaceLineupScRsp = 721 + ChangeLineupLeaderScRsp = 783 + SwapLineupCsReq = 722 + GetAllLineupDataCsReq = 733 + SyncLineupNotify = 772 + VirtualLineupTrialAvatarChangeScNotify = 763 + SetLineupNameScRsp = 743 + ReplaceLineupCsReq = 758 + QuitLineupScRsp = 752 + SetLineupNameCsReq = 739 + JoinLineupCsReq = 776 + GetCurLineupDataCsReq = 731 + GetAllLineupDataScRsp = 742 + ChangeLineupLeaderCsReq = 746 + LobbyInviteCsReq = 7357 + LobbySyncInfoScNotify = 7395 + LobbyJoinCsReq = 7352 + LobbyStartFightCsReq = 7386 + LobbyInteractCsReq = 7376 + LobbyKickOutCsReq = 7393 + LobbyStartFightScRsp = 7367 + LobbyJoinScRsp = 7387 + LobbyGetInfoCsReq = 7382 + LobbyGetInfoScRsp = 7373 + LobbyKickOutScRsp = 7359 + LobbyQuitCsReq = 7390 + LobbyCreateCsReq = 7354 + LobbyModifyPlayerInfoCsReq = 7377 + LobbyInteractScRsp = 7372 + LobbyInviteScRsp = 7400 + LobbyInviteScNotify = 7394 + LobbyQuitScRsp = 7370 + LobbyCreateScRsp = 7396 + LobbyModifyPlayerInfoScRsp = 7365 + LobbyInteractScNotify = 7366 + MarkReadMailCsReq = 831 + MarkReadMailScRsp = 840 + DelMailScRsp = 848 + TakeMailAttachmentScRsp = 852 + NewMailScNotify = 822 + GetMailScRsp = 832 + GetMailCsReq = 895 + DelMailCsReq = 876 + TakeMailAttachmentCsReq = 871 + GetMapRotationDataCsReq = 6872 + DeployRotaterScRsp = 6848 + LeaveMapRotationRegionScNotify = 6883 + EnterMapRotationRegionCsReq = 6895 + ResetMapRotationRegionCsReq = 6816 + GetMapRotationDataScRsp = 6885 + RotateMapScRsp = 6852 + EnterMapRotationRegionScRsp = 6832 + LeaveMapRotationRegionCsReq = 6822 + LeaveMapRotationRegionScRsp = 6856 + UpdateRotaterScNotify = 6833 + RotateMapCsReq = 6871 + ResetMapRotationRegionScRsp = 6846 + InteractChargerCsReq = 6831 + UpdateEnergyScNotify = 6860 + RemoveRotaterCsReq = 6839 + UpdateMapRotationDataScNotify = 6802 + DeployRotaterCsReq = 6876 + InteractChargerScRsp = 6840 + RemoveRotaterScRsp = 6843 + MarbleUpdateShownSealCsReq = 8277 + MarbleGetDataScRsp = 8283 + MarbleLevelFinishCsReq = 8278 + MarbleUpdateShownSealScRsp = 8273 + MarbleLevelFinishScRsp = 8280 + MarblePvpDataUpdateScNotify = 8279 + MarbleUnlockSealScNotify = 8290 + MarbleShopBuyCsReq = 8274 + MarbleShopBuyScRsp = 8272 + MarbleGetDataCsReq = 8284 + UpdateMarkChestScRsp = 8190 + GetMarkChestScRsp = 8193 + GetMarkChestCsReq = 8194 + MarkChestChangedScNotify = 8184 + UpdateMarkChestCsReq = 8188 + GetCrossInfoCsReq = 7317 + CancelMatchScRsp = 7337 + StartMatchCsReq = 7304 + GetCrossInfoScRsp = 7327 + StartMatchScRsp = 7346 + CancelMatchCsReq = 7302 + MatchResultScNotify = 7336 + MatchThreeSetBirdPosCsReq = 7417 + MatchThreeLevelEndScRsp = 7437 + MatchThreeSetBirdPosScRsp = 7427 + MatchThreeSyncDataScNotify = 7436 + MatchThreeGetDataScRsp = 7446 + MatchThreeLevelEndCsReq = 7402 + MatchThreeGetDataCsReq = 7404 + GetMissionMessageInfoCsReq = 2772 + FinishPerformSectionIdScRsp = 2756 + GetNpcStatusCsReq = 2731 + FinishItemIdCsReq = 2776 + FinishSectionIdScRsp = 2752 + FinishItemIdScRsp = 2748 + GetMissionMessageInfoScRsp = 2785 + FinishSectionIdCsReq = 2771 + FinishPerformSectionIdCsReq = 2722 + GetNpcMessageGroupCsReq = 2795 + GetNpcStatusScRsp = 2740 + GetNpcMessageGroupScRsp = 2732 + DifficultyAdjustmentGetDataScRsp = 4114 + CancelCacheNotifyCsReq = 4122 + CancelCacheNotifyScRsp = 4156 + MazeKillDirectScRsp = 4175 + GetOrigamiPropInfoScRsp = 4139 + DifficultyAdjustmentUpdateDataCsReq = 4184 + GetShareDataCsReq = 4131 + GetMovieRacingDataCsReq = 4142 + UpdateGunPlayDataCsReq = 4111 + TakePictureScRsp = 4148 + GetGunPlayDataCsReq = 4129 + ShareCsReq = 4195 + DifficultyAdjustmentUpdateDataScRsp = 4137 + GetShareDataScRsp = 4140 + TakePictureCsReq = 4176 + SubmitOrigamiItemScRsp = 4160 + MazeKillDirectCsReq = 4130 + DifficultyAdjustmentGetDataCsReq = 4125 + SecurityReportScRsp = 4185 + TriggerVoiceScRsp = 4146 + TriggerVoiceCsReq = 4116 + UpdateGunPlayDataScRsp = 4193 + GetOrigamiPropInfoCsReq = 4102 + GetMovieRacingDataScRsp = 4177 + UpdateMovieRacingDataCsReq = 4158 + SecurityReportCsReq = 4172 + GetGunPlayDataScRsp = 4163 + UpdateMovieRacingDataScRsp = 4121 + SubmitOrigamiItemCsReq = 4183 + ShareScRsp = 4132 + SubMissionRewardScNotify = 1263 + StartFinishMainMissionScNotify = 1214 + UpdateMainMissionCustomValueScRsp = 1264 + StartFinishSubMissionScNotify = 1225 + GetMissionDataScRsp = 1232 + GetMissionStatusCsReq = 1233 + GetMainMissionCustomValueScRsp = 1275 + FinishedMissionScNotify = 1207 + GetMissionStatusScRsp = 1242 + SyncTaskScRsp = 1271 + GetMainMissionCustomValueCsReq = 1230 + UpdateMainMissionCustomValueCsReq = 1298 + FinishTalkMissionCsReq = 1231 + UpdateTrackMainMissionIdCsReq = 1224 + TeleportToMissionResetPointScRsp = 1293 + AcceptMainMissionScRsp = 1237 + MissionAcceptScNotify = 1251 + AcceptMainMissionCsReq = 1284 + FinishTalkMissionScRsp = 1240 + MissionGroupWarnScNotify = 1285 + UpdateTrackMainMissionIdScRsp = 1257 + SyncTaskCsReq = 1248 + FinishCosumeItemMissionScRsp = 1246 + GetMissionDataCsReq = 1295 + FinishCosumeItemMissionCsReq = 1216 + TeleportToMissionResetPointCsReq = 1211 + MissionRewardScNotify = 1276 + MonopolySelectOptionScRsp = 7072 + MonopolyScrachRaffleTicketScRsp = 7070 + MonopolyCellUpdateNotify = 7040 + MonopolyBuyGoodsScRsp = 7077 + MonopolyClickMbtiReportScRsp = 7038 + MonopolyTakeRaffleTicketRewardScRsp = 7097 + GetMbtiReportScRsp = 7001 + MonopolyAcceptQuizScRsp = 7057 + MonopolyGameBingoFlipCardScRsp = 7091 + MonopolyGetRegionProgressScRsp = 7018 + GetMonopolyFriendRankingListScRsp = 7087 + GetMonopolyDailyReportScRsp = 7015 + MonopolyGameCreateScNotify = 7007 + MonopolyMoveCsReq = 7052 + MonopolyGuessBuyInformationCsReq = 7006 + MonopolyGetRafflePoolInfoCsReq = 7044 + MonopolyConfirmRandomScRsp = 7033 + MonopolyGuessBuyInformationScRsp = 7045 + MonopolySocialEventEffectScNotify = 7094 + MonopolyRollDiceCsReq = 7048 + MonopolyGameRaiseRatioScRsp = 7084 + MonopolyActionResultScNotify = 7031 + MonopolyBuyGoodsCsReq = 7042 + MonopolyMoveScRsp = 7022 + MonopolyEventLoadUpdateScNotify = 7096 + MonopolyClickCellCsReq = 7055 + MonopolyConfirmRandomCsReq = 7043 + MonopolyGuessChooseScRsp = 7064 + MonopolyGiveUpCurContentScRsp = 7063 + MonopolyTakeRaffleTicketRewardCsReq = 7010 + MonopolyGetDailyInitItemScRsp = 7019 + GetSocialEventServerCacheScRsp = 7074 + MonopolyGameSettleScNotify = 7037 + MonopolyGiveUpCurContentCsReq = 7029 + GetMonopolyFriendRankingListCsReq = 7099 + MonopolyGetRegionProgressCsReq = 7004 + MonopolyGameGachaScRsp = 7075 + MonopolyConditionUpdateScNotify = 7089 + MonopolyLikeCsReq = 7008 + MonopolyUpgradeAssetScRsp = 7021 + MonopolyContentUpdateScNotify = 7025 + MonopolyGetDailyInitItemCsReq = 7050 + MonopolyLikeScRsp = 7035 + MonopolyAcceptQuizCsReq = 7024 + MonopolyLikeScNotify = 7034 + MonopolyReRollRandomCsReq = 7002 + MonopolyUpgradeAssetCsReq = 7058 + MonopolyClickCellScRsp = 7080 + MonopolyTakePhaseRewardCsReq = 7073 + MonopolyGameRaiseRatioCsReq = 7014 + GetMbtiReportCsReq = 7068 + MonopolyGuessChooseCsReq = 7098 + MonopolyCheatDiceCsReq = 7011 + GetMonopolyInfoScRsp = 7032 + MonopolyDailySettleScNotify = 7054 + MonopolyGetRaffleTicketCsReq = 7049 + MonopolyReRollRandomScRsp = 7039 + GetSocialEventServerCacheCsReq = 7027 + GetMonopolyDailyReportCsReq = 7028 + MonopolyGetRafflePoolInfoScRsp = 7026 + DeleteSocialEventServerCacheCsReq = 7090 + DeleteSocialEventServerCacheScRsp = 7017 + MonopolyCheatDiceScRsp = 7093 + MonopolyClickMbtiReportCsReq = 7088 + GetMonopolyMbtiReportRewardCsReq = 7041 + MonopolySttUpdateScNotify = 7012 + MonopolyEventSelectFriendScRsp = 7036 + DailyFirstEnterMonopolyActivityCsReq = 7016 + MonopolyScrachRaffleTicketCsReq = 7079 + MonopolyGameGachaCsReq = 7030 + GetMonopolyMbtiReportRewardScRsp = 7062 + DailyFirstEnterMonopolyActivityScRsp = 7046 + MonopolyGuessDrawScNotify = 7013 + MonopolyTakePhaseRewardScRsp = 7067 + MonopolyRollRandomCsReq = 7083 + MonopolyGameBingoFlipCardCsReq = 7051 + MonopolyGetRaffleTicketScRsp = 7003 + MonopolyRollDiceScRsp = 7071 + MonopolyEventSelectFriendCsReq = 7053 + MonopolyRollRandomScRsp = 7060 + GetMonopolyInfoCsReq = 7095 + MonopolyQuizDurationChangeScNotify = 7078 + MonopolySelectOptionCsReq = 7056 + MultiplayerFightGameStateCsReq = 1095 + MultiplayerMatch3FinishScNotify = 1022 + MultiplayerGetFightGateCsReq = 1031 + MultiplayerFightGameStartScNotify = 1071 + MultiplayerFightGameStateScRsp = 1032 + MultiplayerFightGiveUpCsReq = 1076 + MultiplayerGetFightGateScRsp = 1040 + MultiplayerFightGiveUpScRsp = 1048 + MultiplayerFightGameFinishScNotify = 1052 + MultipleDropInfoScNotify = 4631 + GetMultipleDropInfoScRsp = 4632 + GetPlayerReturnMultiDropInfoScRsp = 4676 + MultipleDropInfoNotify = 4648 + GetPlayerReturnMultiDropInfoCsReq = 4640 + GetMultipleDropInfoCsReq = 4695 + MuseumFundsChangedScNotify = 4339 + MuseumTargetRewardNotify = 4311 + MuseumTargetStartNotify = 4329 + MuseumDispatchFinishedScNotify = 4321 + GetStuffScNotify = 4322 + RemoveStuffFromAreaScRsp = 4352 + MuseumTargetMissionFinishNotify = 4363 + FinishCurTurnCsReq = 4372 + RemoveStuffFromAreaCsReq = 4371 + MuseumInfoChangedScNotify = 4302 + MuseumRandomEventQueryCsReq = 4333 + MuseumRandomEventSelectCsReq = 4377 + MuseumTakeCollectRewardScRsp = 4325 + BuyNpcStuffCsReq = 4331 + GetMuseumInfoCsReq = 4395 + MuseumRandomEventSelectScRsp = 4358 + SetStuffToAreaScRsp = 4348 + UpgradeAreaScRsp = 4346 + UpgradeAreaCsReq = 4316 + GetExhibitScNotify = 4356 + MuseumTakeCollectRewardCsReq = 4393 + UpgradeAreaStatCsReq = 4383 + UpgradeAreaStatScRsp = 4360 + SetStuffToAreaCsReq = 4376 + MuseumRandomEventQueryScRsp = 4342 + GetMuseumInfoScRsp = 4332 + MuseumRandomEventStartScNotify = 4343 + BuyNpcStuffScRsp = 4340 + FinishCurTurnScRsp = 4385 + MusicRhythmDataCsReq = 7573 + MusicRhythmStartLevelScRsp = 7589 + MusicRhythmDataScRsp = 7590 + MusicRhythmSaveSongConfigDataScRsp = 7600 + MusicRhythmFinishLevelCsReq = 7571 + MusicRhythmUnlockSongSfxScNotify = 7592 + MusicRhythmSaveSongConfigDataCsReq = 7588 + MusicRhythmUnlockTrackScNotify = 7577 + MusicRhythmStartLevelCsReq = 7596 + MusicRhythmUnlockSongNotify = 7581 + MusicRhythmMaxDifficultyLevelsUnlockNotify = 7579 + MusicRhythmFinishLevelScRsp = 7594 + GetOfferingInfoCsReq = 6934 + SubmitOfferingItemCsReq = 6928 + TakeOfferingRewardScRsp = 6922 + GetOfferingInfoScRsp = 6933 + SubmitOfferingItemScRsp = 6930 + OfferingInfoScNotify = 6940 + TakeOfferingRewardCsReq = 6924 + SyncAcceptedPamMissionNotify = 4031 + AcceptedPamMissionExpireCsReq = 4095 + AcceptedPamMissionExpireScRsp = 4032 + GetPamSkinDataCsReq = 8134 + SelectPamSkinCsReq = 8128 + UnlockPamSkinScNotify = 8124 + SelectPamSkinScRsp = 8130 + GetPamSkinDataScRsp = 8133 + ParkourGetDataCsReq = 8394 + ParkourEndLevelCsReq = 8400 + ParkourStartLevelCsReq = 8384 + ParkourStartLevelScRsp = 8382 + ParkourGetRankingInfoCsReq = 8388 + ParkourEndLevelScRsp = 8389 + ParkourGetRankingInfoScRsp = 8390 + ParkourGetDataScRsp = 8393 + SummonPetScRsp = 7619 + CurPetChangedScNotify = 7603 + RecallPetScRsp = 7601 + SummonPetCsReq = 7609 + GetPetDataScRsp = 7620 + GetPetDataCsReq = 7611 + RecallPetCsReq = 7624 + UnlockPhoneCaseScNotify = 5172 + SelectPhoneCaseScRsp = 5156 + SelectPhoneThemeCsReq = 5148 + SelectPhoneThemeScRsp = 5171 + UnlockPhoneThemeScNotify = 5152 + SelectChatBubbleCsReq = 5131 + GetPhoneDataScRsp = 5132 + UnlockChatBubbleScNotify = 5176 + SelectChatBubbleScRsp = 5140 + GetPhoneDataCsReq = 5195 + SelectPhoneCaseCsReq = 5122 + PlanetFesGetFriendRankingInfoListScRsp = 8247 + PlanetFesCollectIncomeScRsp = 8236 + PlanetFesGetBusinessDayInfoCsReq = 8222 + PlanetFesDeliverPamCargoScRsp = 8218 + PlanetFesSetCustomKeyValueScRsp = 8248 + PlanetFesUpgradeFesLevelScRsp = 8233 + GetPlanetFesDataScRsp = 8246 + PlanetFesUseItemCsReq = 8214 + PlanetFesGetAvatarStatScRsp = 8230 + PlanetFesDoGachaScRsp = 8220 + PlanetFesBonusEventInteractScRsp = 8219 + PlanetFesClientStatusCsReq = 8209 + PlanetFesChooseAvatarEventOptionCsReq = 8201 + PlanetFesStartMiniGameScRsp = 8249 + PlanetFesGameBingoFlipScRsp = 8225 + PlanetFesSetAvatarWorkScRsp = 8227 + PlanetFesGetBusinessDayInfoScRsp = 8216 + PlanetFesUpgradeSkillLevelCsReq = 8211 + PlanetFesCollectIncomeCsReq = 8237 + PlanetFesBuyLandCsReq = 8215 + PlanetFesClientStatusScRsp = 8245 + PlanetFesAvatarLevelUpCsReq = 8244 + PlanetFesUpgradeFesLevelCsReq = 8241 + PlanetFesBonusEventInteractCsReq = 8210 + PlanetFesDeliverPamCargoCsReq = 8234 + PlanetFesAvatarLevelUpScRsp = 8232 + PlanetFesDealAvatarEventOptionItemScRsp = 8239 + PlanetFesCollectAllIncomeCsReq = 8207 + GetPlanetFesDataCsReq = 8204 + PlanetFesGetFriendRankingInfoListCsReq = 8203 + PlanetFesTakeRegionPhaseRewardCsReq = 8213 + PlanetFesDealAvatarEventOptionItemCsReq = 8235 + PlanetFesBusinessDayRefreshEventCsReq = 8242 + PlanetFesBusinessDayRefreshEventScRsp = 8229 + PlanetFesUseItemScRsp = 8208 + PlanetFesGetAvatarStatCsReq = 8231 + PlanetFesTakeQuestRewardCsReq = 8223 + PlanetFesSyncChangeScNotify = 8202 + PlanetFesDoGachaCsReq = 8240 + PlanetFesTakeRegionPhaseRewardScRsp = 8206 + PlanetFesCollectAllIncomeScRsp = 8250 + PlanetFesFriendRankingInfoChangeScNotify = 8224 + PlanetFesUpgradeSkillLevelScRsp = 8238 + PlanetFesChooseAvatarEventOptionScRsp = 8205 + PlanetFesBuyLandScRsp = 8243 + PlanetFesGameBingoFlipCsReq = 8228 + PlanetFesSetCustomKeyValueCsReq = 8212 + PlanetFesStartMiniGameCsReq = 8221 + PlanetFesSetAvatarWorkCsReq = 8217 + PlanetFesTakeQuestRewardScRsp = 8226 + PlanetFesApplyCardPieceCsReq = 8317 + PlanetFesGetOfferedCardPieceScRsp = 8297 + PlanetFesLargeBonusInteractScRsp = 8334 + PlanetFesLargeBonusInteractCsReq = 8310 + PlanetFesGiveCardPieceScRsp = 8330 + PlanetFesChangeCardPieceApplyPermissionCsReq = 8326 + PlanetFesHandleCardPieceApplyScRsp = 8299 + PlanetFesGetExtraCardPieceInfoScRsp = 8336 + PlanetFesEnterNextBusinessDayCsReq = 8322 + PlanetFesHandleCardPieceApplyCsReq = 8333 + PlanetFesGetOfferedCardPieceCsReq = 8335 + PlanetFesGiveCardPieceCsReq = 8340 + PlanetFesApplyCardPieceScRsp = 8305 + PlanetFesGetExtraCardPieceInfoCsReq = 8294 + PlanetFesGetFriendCardPieceCsReq = 8292 + PlanetFesGetFriendCardPieceScRsp = 8327 + PlanetFesEnterNextBusinessDayScRsp = 8313 + PlanetFesChangeCardPieceApplyPermissionScRsp = 8307 + GetBasicInfoCsReq = 86 + AntiAddictScNotify = 43 + AvatarPathChangedNotify = 19 + PlayerHeartBeatScRsp = 1 + UpdatePsnSettingsInfoCsReq = 12 + ExchangeStaminaCsReq = 46 + GetGameStateServiceConfigScRsp = 47 + GateServerScNotify = 53 + QueryProductInfoScRsp = 13 + GetBasicInfoScRsp = 100 + SetAvatarPathCsReq = 15 + ReserveStaminaExchangeScRsp = 4 + SetNicknameScRsp = 42 + RetcodeNotify = 34 + ClientObjDownloadDataScNotify = 73 + UpdatePlayerSettingScRsp = 26 + GetAuthkeyCsReq = 60 + StaminaInfoScNotify = 18 + PlayerGetTokenCsReq = 76 + GetLevelRewardCsReq = 21 + SetGenderScRsp = 7 + AceAntiCheaterCsReq = 87 + GetVideoVersionKeyCsReq = 49 + PlayerLoginScRsp = 32 + SetMultipleAvatarPathsCsReq = 38 + PlayerLoginFinishCsReq = 17 + GmTalkCsReq = 56 + UnlockAvatarPathCsReq = 89 + PlayerLoginCsReq = 95 + AceAntiCheaterScRsp = 8 + UpdatePsnSettingsInfoScRsp = 41 + GetLevelRewardTakenListScRsp = 58 + SetRedPointStatusScNotify = 10 + RegionStopScNotify = 39 + GetMultiPathAvatarInfoCsReq = 80 + FeatureSwitchClosedScNotify = 36 + SetPlayerInfoCsReq = 98 + ServerAnnounceNotify = 14 + GetLevelRewardScRsp = 29 + PlayerGetTokenScRsp = 48 + PlayerKickOutScNotify = 22 + PlayerLogoutCsReq = 31 + SetNicknameCsReq = 33 + SetGameplayBirthdayCsReq = 54 + SetPlayerInfoScRsp = 64 + SetGameplayBirthdayScRsp = 99 + SetLanguageScRsp = 25 + ExchangeStaminaScRsp = 83 + PlayerLoginFinishScRsp = 69 + ReserveStaminaExchangeCsReq = 70 + SetAvatarPathScRsp = 55 + GetSecretKeyInfoCsReq = 74 + PlayerHeartBeatCsReq = 68 + DailyRefreshNotify = 9 + GetVideoVersionKeyScRsp = 3 + UpdateFeatureSwitchScNotify = 20 + UnlockAvatarPathScRsp = 88 + GetLevelRewardTakenListCsReq = 77 + SetLanguageCsReq = 93 + SetGenderCsReq = 57 + PlayerLogoutScRsp = 40 + UpdatePlayerSettingCsReq = 44 + ClientObjUploadCsReq = 67 + QueryProductInfoCsReq = 45 + GmTalkScNotify = 52 + ClientDownloadDataScNotify = 78 + ClientObjUploadScRsp = 96 + GetMultiPathAvatarInfoScRsp = 50 + SetMultipleAvatarPathsScRsp = 5 + GetGameStateServiceConfigCsReq = 82 + MonthCardRewardNotify = 35 + GetAuthkeyScRsp = 2 + GmTalkScRsp = 72 + GetSecretKeyInfoScRsp = 90 + SetIsDisplayAvatarInfoCsReq = 2871 + SetPersonalCardScRsp = 2883 + SetPersonalCardCsReq = 2846 + SetAssistAvatarCsReq = 2885 + SetDisplayAvatarCsReq = 2876 + SetHeadIconScRsp = 2840 + SetSignatureScRsp = 2872 + SetIsDisplayAvatarInfoScRsp = 2852 + SetAssistAvatarScRsp = 2816 + GetPlayerBoardDataCsReq = 2895 + GetPlayerBoardDataScRsp = 2832 + SetDisplayAvatarScRsp = 2848 + UnlockHeadIconScNotify = 2822 + SetSignatureCsReq = 2856 + SetHeadIconCsReq = 2831 + PlayerReturnTakePointRewardScRsp = 4548 + PlayerReturnTakeRewardScRsp = 4552 + PlayerReturnForceFinishScNotify = 4572 + PlayerReturnTakeRewardCsReq = 4571 + PlayerReturnInfoQueryCsReq = 4522 + PlayerReturnTakeRelicCsReq = 4585 + PlayerReturnSignCsReq = 4532 + PlayerReturnTakeRelicScRsp = 4516 + PlayerReturnPointChangeScNotify = 4540 + PlayerReturnStartScNotify = 4595 + PlayerReturnTakePointRewardCsReq = 4576 + PlayerReturnSignScRsp = 4531 + PlayerReturnInfoQueryScRsp = 4556 + FinishPlotCsReq = 1195 + FinishPlotScRsp = 1132 + SharePunkLordMonsterCsReq = 3276 + PunkLordMonsterInfoScNotify = 3283 + GetPunkLordMonsterDataCsReq = 3295 + PunkLordRaidTimeOutScNotify = 3243 + StartPunkLordRaidCsReq = 3231 + GetPunkLordBattleRecordScRsp = 3230 + TakeKilledPunkLordMonsterScoreCsReq = 3225 + PunkLordMonsterKilledNotify = 3293 + GetPunkLordMonsterDataScRsp = 3232 + SummonPunkLordMonsterScRsp = 3252 + GetPunkLordDataScRsp = 3202 + SummonPunkLordMonsterCsReq = 3271 + TakePunkLordPointRewardScRsp = 3246 + TakePunkLordPointRewardCsReq = 3216 + PunkLordBattleResultScNotify = 3258 + GetPunkLordBattleRecordCsReq = 3237 + GetPunkLordDataCsReq = 3260 + PunkLordDataChangeNotify = 3284 + TakeKilledPunkLordMonsterScoreScRsp = 3214 + GetKilledPunkLordMonsterDataCsReq = 3221 + SharePunkLordMonsterScRsp = 3248 + StartPunkLordRaidScRsp = 3240 + GetKilledPunkLordMonsterDataScRsp = 3229 + TakeQuestOptionalRewardCsReq = 985 + GetQuestRecordCsReq = 971 + TakeQuestRewardCsReq = 931 + TakeQuestOptionalRewardScRsp = 916 + QuestRecordScNotify = 922 + TakeQuestRewardScRsp = 940 + GetQuestDataScRsp = 932 + GetQuestDataCsReq = 995 + GetQuestRecordScRsp = 952 + BatchGetQuestDataCsReq = 983 + FinishQuestCsReq = 956 + BatchGetQuestDataScRsp = 960 + FinishQuestScRsp = 972 + StartRaidScRsp = 2232 + RaidInfoNotify = 2276 + LeaveRaidScRsp = 2240 + DelSaveRaidScNotify = 2243 + GetSaveRaidCsReq = 2283 + GetAllSaveRaidCsReq = 2202 + StartRaidCsReq = 2295 + GetSaveRaidScRsp = 2260 + GetRaidInfoCsReq = 2272 + TakeChallengeRaidRewardCsReq = 2252 + GetRaidInfoScRsp = 2285 + GetChallengeRaidInfoCsReq = 2248 + SetClientRaidTargetCountCsReq = 2216 + LeaveRaidCsReq = 2231 + ChallengeRaidNotify = 2256 + GetAllSaveRaidScRsp = 2239 + GetChallengeRaidInfoScRsp = 2271 + TakeChallengeRaidRewardScRsp = 2222 + RaidKickByServerScNotify = 2233 + SetClientRaidTargetCountScRsp = 2246 + RaidCollectionDataCsReq = 6954 + RaidCollectionDataScNotify = 6948 + RaidCollectionDataScRsp = 6953 + RaidCollectionEnterNextRaidCsReq = 6950 + RaidCollectionEnterNextRaidScRsp = 6944 + GetRechargeGiftInfoCsReq = 8374 + GetRechargeGiftInfoScRsp = 8373 + GetRechargeBenefitInfoCsReq = 8364 + TakeRechargeGiftRewardCsReq = 8368 + TakeRechargeBenefitRewardCsReq = 8369 + SyncRechargeBenefitInfoScNotify = 8380 + TakeRechargeGiftRewardScRsp = 8370 + TakeRechargeBenefitRewardScRsp = 8367 + GetRechargeBenefitInfoScRsp = 8362 + GetBigDataAllRecommendScRsp = 2409 + GetChallengeRecommendLineupListScRsp = 2417 + GetBigDataRecommendScRsp = 2415 + GetBigDataAllRecommendCsReq = 2443 + GetBigDataRecommendCsReq = 2427 + GetChallengeRecommendLineupListCsReq = 2436 + GetSingleRedDotParamGroupCsReq = 5976 + UpdateRedDotDataScRsp = 5940 + GetSingleRedDotParamGroupScRsp = 5948 + GetAllRedDotDataScRsp = 5932 + UpdateRedDotDataCsReq = 5931 + GetAllRedDotDataCsReq = 5995 + RelicSmartWearUpdatePlanCsReq = 8254 + RelicSmartWearPinRelicScRsp = 8253 + RelicSmartWearGetPlanScRsp = 8263 + RelicSmartWearUpdatePlanScRsp = 8252 + RelicSmartWearAddPlanCsReq = 8258 + RelicSmartWearUpdatePinRelicScNotify = 8261 + RelicSmartWearPinRelicCsReq = 8257 + RelicSmartWearDeletePlanCsReq = 8270 + RelicSmartWearGetPinRelicCsReq = 8255 + RelicSmartWearDeletePlanScRsp = 8259 + RelicSmartWearAddPlanScRsp = 8260 + RelicSmartWearGetPlanCsReq = 8264 + RelicSmartWearGetPinRelicScRsp = 8251 + GetReplayTokenCsReq = 3595 + GetPlayerReplayInfoScRsp = 3540 + GetReplayTokenScRsp = 3532 + GetPlayerReplayInfoCsReq = 3531 + DailyFirstMeetPamScRsp = 3440 + DailyFirstMeetPamCsReq = 3431 + GetRndOptionCsReq = 3495 + GetRndOptionScRsp = 3432 + EnableRogueTalentScRsp = 1805 + FinishAeonDialogueGroupScRsp = 1819 + QuitRogueCsReq = 1837 + ExchangeRogueRewardKeyCsReq = 1868 + TakeRogueScoreRewardScRsp = 1877 + EnterRogueCsReq = 1876 + GetRogueInitialScoreCsReq = 1864 + GetRogueTalentInfoScRsp = 1888 + SyncRogueRewardInfoScNotify = 1866 + EnterRogueScRsp = 1848 + SyncRogueMapRoomScNotify = 1845 + FinishAeonDialogueGroupCsReq = 1850 + GetRogueInfoCsReq = 1895 + GetRogueAeonInfoCsReq = 1855 + ReviveRogueAvatarScRsp = 1833 + StartRogueCsReq = 1831 + EnhanceRogueBuffScRsp = 1863 + SyncRogueVirtualItemInfoScNotify = 1865 + LeaveRogueCsReq = 1871 + OpenRogueChestScRsp = 1834 + SyncRogueAreaUnlockScNotify = 1810 + SyncRogueStatusScNotify = 1881 + ReviveRogueAvatarCsReq = 1843 + GetRogueTalentInfoCsReq = 1889 + TakeRogueScoreRewardCsReq = 1842 + PickRogueAvatarScRsp = 1802 + GetRogueBuffEnhanceInfoScRsp = 1821 + EnterRogueMapRoomScRsp = 1898 + SyncRogueReviveInfoScNotify = 1884 + SyncRogueExploreWinScNotify = 1851 + SyncRogueFinishScNotify = 1883 + SyncRoguePickAvatarInfoScNotify = 1861 + TakeRogueAeonLevelRewardScRsp = 1870 + QuitRogueScRsp = 1830 + StartRogueScRsp = 1840 + LeaveRogueScRsp = 1852 + TakeRogueAeonLevelRewardCsReq = 1879 + ExchangeRogueRewardKeyScRsp = 1801 + GetRogueScoreRewardInfoCsReq = 1873 + GetRogueAeonInfoScRsp = 1880 + SyncRogueAeonScNotify = 1803 + GetRogueInfoScRsp = 1832 + GetRogueBuffEnhanceInfoCsReq = 1858 + SyncRogueSeasonFinishScNotify = 1891 + OpenRogueChestCsReq = 1835 + SyncRogueGetItemScNotify = 1897 + GetRogueInitialScoreScRsp = 1806 + EnhanceRogueBuffCsReq = 1829 + PickRogueAvatarCsReq = 1860 + EnableRogueTalentCsReq = 1838 + GetRogueScoreRewardInfoScRsp = 1867 + EnterRogueMapRoomCsReq = 1807 + SyncRogueAeonLevelUpRewardScNotify = 1826 + RogueArcadeLeaveScRsp = 7687 + RogueArcadeRestartCsReq = 7686 + RogueArcadeGetInfoScRsp = 7665 + RogueArcadeStartCsReq = 7654 + RogueArcadeGetInfoCsReq = 7677 + RogueArcadeLeaveCsReq = 7652 + RogueArcadeRestartScRsp = 7667 + RogueArcadeStartScRsp = 7696 + GetRogueHandbookDataScRsp = 5657 + HandleRogueCommonPendingActionScRsp = 5608 + CommonRogueQueryScRsp = 5634 + RogueShopBeginBattleScRsp = 5623 + FinishRogueCommonDialogueScRsp = 5674 + GetRogueCommonDialogueDataCsReq = 5601 + GetRogueShopMiracleInfoCsReq = 5640 + BuyRogueShopFormulaCsReq = 5682 + RogueGetGambleInfoScRsp = 5615 + EnhanceCommonRogueBuffScRsp = 5621 + TakeRogueMiracleHandbookRewardScRsp = 5664 + RogueWorkbenchHandleFuncScRsp = 5697 + SetRogueCollectionScRsp = 5618 + UpdateRogueAdventureRoomScoreCsReq = 5620 + GetRogueShopFormulaInfoScRsp = 5605 + HandleRogueCommonPendingActionCsReq = 5687 + RogueDoGambleScRsp = 5680 + SelectRogueCommonDialogueOptionScRsp = 5694 + RogueDoGambleCsReq = 5655 + SetRogueExhibitionCsReq = 5673 + GetRogueHandbookDataCsReq = 5624 + CommonRogueUpdateScNotify = 5668 + SyncRogueHandbookDataUpdateScNotify = 5607 + RogueWorkbenchGetInfoScRsp = 5603 + FinishRogueCommonDialogueCsReq = 5627 + StopRogueAdventureRoomCsReq = 5629 + BuyRogueShopMiracleScRsp = 5622 + BuyRogueShopBuffCsReq = 5656 + PrepareRogueAdventureRoomScRsp = 5631 + PrepareRogueAdventureRoomCsReq = 5632 + RogueWorkbenchGetInfoCsReq = 5649 + GetRogueShopFormulaInfoCsReq = 5638 + TakeRogueEventHandbookRewardScRsp = 5645 + GetRogueExhibitionScRsp = 5626 + RogueWorkbenchHandleFuncCsReq = 5610 + BuyRogueShopMiracleCsReq = 5652 + CommonRogueQueryCsReq = 5635 + SetRogueExhibitionScRsp = 5667 + SyncRogueCommonDialogueDataScNotify = 5690 + SyncRogueCommonVirtualItemInfoScNotify = 5700 + GetRogueCollectionCsReq = 5679 + RogueNpcDisappearScRsp = 5616 + UpdateRogueAdventureRoomScoreScRsp = 5686 + BuyRogueShopFormulaScRsp = 5647 + RogueGetGambleInfoCsReq = 5628 + SyncRogueAdventureRoomInfoScNotify = 5695 + RogueDebugReplaySaveScNotify = 5688 + SyncRogueCommonDialogueOptionFinishScNotify = 5617 + GetRogueShopBuffInfoScRsp = 5671 + SetRogueCollectionCsReq = 5604 + StopRogueAdventureRoomScRsp = 5663 + EnhanceCommonRogueBuffCsReq = 5658 + TakeRogueEventHandbookRewardCsReq = 5606 + GetRogueAdventureRoomInfoScRsp = 5683 + SyncRogueCommonActionResultScNotify = 5613 + GetRogueShopMiracleInfoScRsp = 5676 + TakeRogueMiracleHandbookRewardCsReq = 5698 + SelectRogueCommonDialogueOptionCsReq = 5636 + GetEnhanceCommonRogueBuffInfoCsReq = 5642 + RogueShopBeginBattleCsReq = 5692 + RogueNpcDisappearCsReq = 5685 + SyncRogueCommonPendingActionScNotify = 5678 + GetRogueCollectionScRsp = 5670 + GetEnhanceCommonRogueBuffInfoScRsp = 5677 + GetRogueAdventureRoomInfoCsReq = 5646 + GetRogueShopBuffInfoCsReq = 5648 + GetRogueCommonDialogueDataScRsp = 5653 + BuyRogueShopBuffScRsp = 5672 + GetRogueExhibitionCsReq = 5644 + TakeRogueEndlessActivityAllBonusRewardScRsp = 6010 + GetRogueEndlessActivityDataCsReq = 6002 + TakeRogueEndlessActivityPointRewardScRsp = 6006 + EnterRogueEndlessActivityStageCsReq = 6004 + GetRogueEndlessActivityDataScRsp = 6005 + RogueEndlessActivityBattleEndScNotify = 6001 + TakeRogueEndlessActivityAllBonusRewardCsReq = 6003 + TakeRogueEndlessActivityPointRewardCsReq = 6009 + EnterRogueEndlessActivityStageScRsp = 6007 + RogueMagicSetAutoDressInMagicUnitCsReq = 7724 + RogueMagicScepterTakeOffUnitCsReq = 7711 + RogueMagicStartCsReq = 7795 + RogueMagicEnterCsReq = 7731 + RogueMagicScepterDressInUnitScRsp = 7763 + RogueMagicAutoDressInMagicUnitChangeScNotify = 7713 + RogueMagicEnterScRsp = 7740 + RogueMagicScepterDressInUnitCsReq = 7729 + RogueMagicEnterRoomCsReq = 7722 + RogueMagicQueryScRsp = 7758 + RogueMagicEnterLayerCsReq = 7772 + RogueMagicReviveCostUpdateScNotify = 7743 + RogueMagicLevelInfoUpdateScNotify = 7716 + RogueMagicSettleScRsp = 7752 + RogueMagicSettleCsReq = 7771 + RogueMagicScepterTakeOffUnitScRsp = 7793 + RogueMagicStartScRsp = 7732 + RogueMagicEnterRoomScRsp = 7756 + RogueMagicEnableTalentCsReq = 7751 + RogueMagicReviveAvatarCsReq = 7733 + RogueMagicSetAutoDressInMagicUnitScRsp = 7757 + RogueMagicGetMiscRealTimeDataScRsp = 7798 + RogueMagicAreaUpdateScNotify = 7746 + RogueMagicEnterLayerScRsp = 7785 + RogueMagicUnitComposeScRsp = 7714 + RogueMagicLeaveCsReq = 7776 + RogueMagicAutoDressInUnitScRsp = 7706 + RogueMagicAutoDressInUnitCsReq = 7764 + RogueMagicReviveAvatarScRsp = 7742 + RogueMagicBattleFailSettleInfoScNotify = 7739 + RogueMagicLeaveScRsp = 7748 + RogueMagicUnitReforgeCsReq = 7784 + RogueMagicQueryCsReq = 7777 + RogueMagicUnitReforgeScRsp = 7737 + RogueMagicGetTalentInfoCsReq = 7730 + RogueMagicStoryInfoUpdateScNotify = 7745 + RogueMagicGetTalentInfoScRsp = 7775 + RogueMagicUnitComposeCsReq = 7725 + RogueMagicGetMiscRealTimeDataCsReq = 7707 + RogueMagicEnableTalentScRsp = 7791 + RogueModifierSelectCellScRsp = 5376 + RogueModifierDelNotify = 5322 + RogueModifierUpdateNotify = 5352 + RogueModifierStageStartNotify = 5356 + RogueModifierAddNotify = 5331 + RogueModifierSelectCellCsReq = 5340 + RogueTournGetArchiveRepositoryCsReq = 6074 + RogueTournAreaUpdateScNotify = 6040 + RogueTournLeaveCsReq = 6026 + RogueTournGetMiscRealTimeDataCsReq = 6045 + RogueTournConfirmSettleCsReq = 6088 + RogueTournDeleteArchiveCsReq = 6043 + RogueTournDeleteBuildRefScRsp = 6083 + RogueTournGetCurRogueCocoonInfoCsReq = 6055 + RogueTournRenameArchiveCsReq = 6024 + RogueTournReEnterRogueCocoonStageCsReq = 6027 + RogueTournStartCsReq = 6032 + RogueTournEnterLayerScRsp = 6073 + RogueTournEnablePermanentTalentScRsp = 6058 + RogueTournQueryCsReq = 6095 + RogueTournRenameArchiveScRsp = 6093 + RogueTournSaveBuildRefScRsp = 6020 + RogueTournTakeExpRewardScRsp = 6094 + RogueTournGetCurRogueCocoonInfoScRsp = 6063 + RogueTournConfirmSettleScRsp = 6090 + RogueTournReEnterRogueCocoonStageScRsp = 6016 + RogueTournExpNotify = 6030 + RogueTournEnterCsReq = 6064 + RogueTournStartScRsp = 6078 + RogueTournQueryScRsp = 6052 + RogueTournRenameBuildRefScRsp = 6028 + RogueTournEnableSeasonTalentScRsp = 6041 + RogueTournLeaveScRsp = 6042 + RogueTournTitanUpdateTitanBlessProgressScNotify = 6053 + RogueTournWeekChallengeUpdateScNotify = 6018 + RogueTournEnterLayerCsReq = 6081 + RogueTournEnableSeasonTalentCsReq = 6019 + RogueTournGetAllBuildRefCsReq = 6035 + RogueTournSaveBuildRefCsReq = 6012 + RogueTournTakeExpRewardCsReq = 6039 + RogueTournClearArchiveNameScNotify = 6082 + RogueTournDeleteArchiveScRsp = 6049 + RogueTournGetSeasonTalentInfoCsReq = 6079 + RogueTournEnterRogueCocoonSceneScRsp = 6062 + RogueTournGetAllBuildRefScRsp = 6046 + RogueTournReviveAvatarCsReq = 6098 + RogueTournBattleFailSettleInfoScNotify = 6037 + RogueTournGetSeasonTalentInfoScRsp = 6097 + RogueTournEnablePermanentTalentCsReq = 6013 + RogueTournEnterRoomScRsp = 6061 + RogueTournLevelInfoUpdateScNotify = 6087 + RogueTournReviveAvatarScRsp = 6047 + RogueTournResetPermanentTalentScRsp = 6089 + RogueTournSettleCsReq = 6080 + RogueTournEnterScRsp = 6070 + RogueTournDeleteBuildRefCsReq = 6085 + RogueTournReviveCostUpdateScNotify = 6086 + RogueTournGetPermanentTalentInfoCsReq = 6099 + RogueTournSettleScRsp = 6056 + RogueTournResetPermanentTalentCsReq = 6031 + RogueTournDifficultyCompNotify = 6050 + RogueTournGetPermanentTalentInfoScRsp = 6067 + RogueTournEnterRogueCocoonSceneCsReq = 6034 + RogueTournLeaveRogueCocoonSceneScRsp = 6066 + RogueTournEnterRoomCsReq = 6084 + RogueTournGetSettleInfoCsReq = 6068 + RogueTournLeaveRogueCocoonSceneCsReq = 6017 + RogueTournGetSettleInfoScRsp = 6059 + RogueTournGetAllArchiveCsReq = 6021 + RogueTournGetAllArchiveScRsp = 6100 + RogueTournGetArchiveRepositoryScRsp = 6011 + RogueTournRenameBuildRefCsReq = 6014 + RogueTournHandBookNotify = 6023 + RogueTournGetMiscRealTimeDataScRsp = 6044 + DoGachaInRollShopScRsp = 6910 + TakeRollShopRewardScRsp = 6902 + GetRollShopInfoCsReq = 6914 + TakeRollShopRewardCsReq = 6904 + GetRollShopInfoScRsp = 6913 + DoGachaInRollShopCsReq = 6908 + UpdateMechanismBarScNotify = 1468 + SpringRefreshScRsp = 1443 + SceneCastSkillCostMpScRsp = 1483 + SceneEnterStageScRsp = 1421 + SceneReviveAfterRebattleScRsp = 1463 + GetUnlockTeleportScRsp = 1418 + DeactivateFarmElementCsReq = 1445 + SceneCastSkillScRsp = 1448 + UnlockTeleportNotify = 1466 + ReturnLastTownScRsp = 1477 + ActivateFarmElementScRsp = 1420 + UpdateGroupPropertyCsReq = 1461 + SceneGroupRefreshScNotify = 1412 + GroupStateChangeCsReq = 1428 + RecoverAllLineupScRsp = 1475 + StartCocoonStageCsReq = 1491 + EntityBindPropCsReq = 1457 + EnterSectionCsReq = 1411 + InteractPropCsReq = 1431 + SetClientPausedCsReq = 1498 + SetGroupCustomSaveDataScRsp = 1453 + ReturnLastTownCsReq = 1442 + RefreshTriggerByClientScRsp = 1488 + SceneEntityTeleportCsReq = 1490 + StartCocoonStageScRsp = 1424 + UpdateGroupPropertyScRsp = 1459 + GameplayCounterRecoverCsReq = 1441 + ReEnterLastElementStageCsReq = 1427 + SceneEnterStageCsReq = 1458 + GetCurSceneInfoScRsp = 1452 + SceneUpdatePositionVersionNotify = 1485 + SetCurInteractEntityCsReq = 1484 + SetClientPausedScRsp = 1464 + SyncEntityBuffChangeListScNotify = 1416 + EnterSceneCsReq = 1469 + GroupStateChangeScRsp = 1415 + SetCurInteractEntityScRsp = 1437 + EnteredSceneChangeScNotify = 1419 + GetEnteredSceneScRsp = 1450 + DeleteSummonUnitCsReq = 1405 + SpringRefreshCsReq = 1439 + GameplayCounterCountDownScRsp = 1467 + DeactivateFarmElementScRsp = 1413 + OpenChestScNotify = 1444 + DeleteSummonUnitScRsp = 1482 + SyncServerSceneChangeNotify = 1470 + LastSpringRefreshTimeNotify = 1433 + SceneEntityMoveScRsp = 1432 + RefreshTriggerByClientScNotify = 1438 + GameplayCounterCountDownCsReq = 1473 + TrainWorldIdChangeScNotify = 1492 + RecoverAllLineupCsReq = 1430 + SceneCastSkillCostMpCsReq = 1446 + EnterSceneScRsp = 1449 + GameplayCounterRecoverScRsp = 1462 + SceneReviveAfterRebattleCsReq = 1429 + UnlockedAreaMapScNotify = 1447 + ChangePropTimelineInfoCsReq = 1422 + GetSceneMapInfoScRsp = 1479 + SavePointsInfoNotify = 1451 + GetUnlockTeleportCsReq = 1404 + UpdateFloorSavedValueNotify = 1426 + GetSceneMapInfoCsReq = 1497 + EnterSceneByServerScNotify = 1403 + ReEnterLastElementStageScRsp = 1474 + EnterSectionScRsp = 1493 + GroupStateChangeScNotify = 1455 + SetGroupCustomSaveDataCsReq = 1401 + SceneCastSkillMpUpdateScNotify = 1460 + ChangePropTimelineInfoScRsp = 1456 + GameplayCounterUpdateScNotify = 1496 + SceneCastSkillCsReq = 1476 + InteractPropScRsp = 1440 + GetEnteredSceneCsReq = 1480 + SceneEntityMoveCsReq = 1495 + GetCurSceneInfoCsReq = 1471 + SceneEntityTeleportScRsp = 1417 + SceneEntityMoveScNotify = 1472 + ActivateFarmElementCsReq = 1478 + RefreshTriggerByClientCsReq = 1489 + ScenePlaneEventScNotify = 1410 + EntityBindPropScRsp = 1407 + UpdateServerPrefsDataCsReq = 6176 + GetAllServerPrefsDataCsReq = 6195 + UpdateServerPrefsDataScRsp = 6148 + GetServerPrefsDataCsReq = 6131 + GetAllServerPrefsDataScRsp = 6132 + GetServerPrefsDataScRsp = 6140 + BuyGoodsCsReq = 1531 + GetShopListCsReq = 1595 + BuyGoodsScRsp = 1540 + TakeCityShopRewardScRsp = 1548 + TakeCityShopRewardCsReq = 1576 + CityShopInfoScNotify = 1571 + GetShopListScRsp = 1532 + SpaceZooBornScRsp = 6740 + SpaceZooDataScRsp = 6732 + SpaceZooDataCsReq = 6795 + SpaceZooMutateCsReq = 6776 + SpaceZooBornCsReq = 6731 + SpaceZooExchangeItemCsReq = 6785 + SpaceZooOpCatteryScRsp = 6752 + SpaceZooCatUpdateNotify = 6772 + SpaceZooExchangeItemScRsp = 6716 + SpaceZooOpCatteryCsReq = 6771 + SpaceZooTakeCsReq = 6746 + SpaceZooDeleteCatScRsp = 6756 + SpaceZooTakeScRsp = 6783 + SpaceZooMutateScRsp = 6748 + SpaceZooDeleteCatCsReq = 6722 + GetStarFightDataCsReq = 7162 + GetStarFightDataScRsp = 7165 + StartStarFightLevelScRsp = 7167 + StartStarFightLevelCsReq = 7164 + StarFightDataChangeNotify = 7161 + ChangeStoryLineFinishScNotify = 6248 + GetStoryLineInfoCsReq = 6295 + StoryLineTrialAvatarChangeScNotify = 6271 + StoryLineInfoScNotify = 6231 + GetStoryLineInfoScRsp = 6232 + EnterStrongChallengeActivityStageCsReq = 6631 + StrongChallengeActivityBattleEndScNotify = 6676 + EnterStrongChallengeActivityStageScRsp = 6640 + GetStrongChallengeActivityDataCsReq = 6695 + GetStrongChallengeActivityDataScRsp = 6632 + EnterSummonActivityStageCsReq = 7564 + GetSummonActivityDataScRsp = 7565 + EnterSummonActivityStageScRsp = 7567 + GetSummonActivityDataCsReq = 7562 + SummonActivityBattleEndScNotify = 7561 + SwitchHandDataScRsp = 8113 + SwitchHandStartScRsp = 8110 + SwitchHandCoinUpdateCsReq = 8107 + SwitchHandUpdateCsReq = 8120 + SwitchHandResetHandPosScRsp = 8101 + SwitchHandCoinUpdateScRsp = 8103 + SwitchHandStartCsReq = 8108 + SwitchHandUpdateScRsp = 8109 + SwitchHandResetGameScRsp = 8119 + SwitchHandResetHandPosCsReq = 8105 + SwitchHandFinishScRsp = 8102 + SwitchHandFinishCsReq = 8104 + SwitchHandDataCsReq = 8114 + SwitchHandResetGameCsReq = 8111 + SwordTrainingGiveUpGameCsReq = 7492 + SwordTrainingDialogueSelectOptionScRsp = 7493 + SwordTrainingResumeGameCsReq = 7453 + SwordTrainingGameSettleScNotify = 7468 + SwordTrainingDailyPhaseConfirmCsReq = 7467 + SwordTrainingResumeGameScRsp = 7497 + SwordTrainingGiveUpGameScRsp = 7479 + SwordTrainingStoryBattleScRsp = 7469 + EnterSwordTrainingExamScRsp = 7470 + SwordTrainingStartGameCsReq = 7473 + SwordTrainingSetSkillTraceScRsp = 7491 + GetSwordTrainingDataCsReq = 7496 + SwordTrainingGameSyncChangeScNotify = 7454 + SwordTrainingStartGameScRsp = 7476 + SwordTrainingSetSkillTraceCsReq = 7498 + SwordTrainingDailyPhaseConfirmScRsp = 7477 + SwordTrainingLearnSkillCsReq = 7494 + SwordTrainingRestoreGameCsReq = 7456 + SwordTrainingMarkEndingViewedCsReq = 7483 + SwordTrainingLearnSkillScRsp = 7482 + SwordTrainingUnlockSyncScNotify = 7451 + SwordTrainingTurnActionScRsp = 7486 + SwordTrainingSelectEndingCsReq = 7489 + GetSwordTrainingDataScRsp = 7452 + EnterSwordTrainingExamCsReq = 7490 + SwordTrainingTurnActionCsReq = 7487 + SwordTrainingStoryBattleCsReq = 7460 + SwordTrainingStoryConfirmScRsp = 7466 + SwordTrainingMarkEndingViewedScRsp = 7481 + SwordTrainingRestoreGameScRsp = 7471 + SwordTrainingActionTurnSettleScNotify = 7499 + SwordTrainingExamResultConfirmCsReq = 7464 + SwordTrainingStoryConfirmCsReq = 7472 + SwordTrainingExamResultConfirmScRsp = 7458 + SwordTrainingDialogueSelectOptionCsReq = 7465 + SwordTrainingSelectEndingScRsp = 7461 + PlayerSyncScNotify = 695 + TakeTalkRewardCsReq = 2131 + FinishFirstTalkByPerformanceNpcCsReq = 2116 + GetFirstTalkNpcScRsp = 2148 + GetFirstTalkByPerformanceNpcCsReq = 2172 + FinishFirstTalkNpcScRsp = 2152 + GetNpcTakenRewardScRsp = 2132 + SelectInclinationTextScRsp = 2156 + TakeTalkRewardScRsp = 2140 + SelectInclinationTextCsReq = 2122 + FinishFirstTalkNpcCsReq = 2171 + GetFirstTalkByPerformanceNpcScRsp = 2185 + GetFirstTalkNpcCsReq = 2176 + GetNpcTakenRewardCsReq = 2195 + FinishFirstTalkByPerformanceNpcScRsp = 2146 + TarotBookFinishStoryCsReq = 8160 + TarotBookFinishInteractionCsReq = 8143 + TarotBookGetDataCsReq = 8154 + TarotBookFinishStoryScRsp = 8149 + TarotBookUnlockStoryScRsp = 8142 + TarotBookModifyEnergyScNotify = 8147 + TarotBookFinishInteractionScRsp = 8145 + TarotBookOpenPackScRsp = 8150 + TarotBookGetDataScRsp = 8153 + TarotBookUnlockStoryCsReq = 8144 + TarotBookOpenPackCsReq = 8148 + TelevisionActivityDataChangeScNotify = 6968 + EnterTelevisionActivityStageScRsp = 6964 + TelevisionActivityBattleEndScNotify = 6962 + GetTelevisionActivityDataScRsp = 6973 + GetTelevisionActivityDataCsReq = 6974 + EnterTelevisionActivityStageCsReq = 6970 + TextJoinSaveCsReq = 3895 + TextJoinSaveScRsp = 3832 + TextJoinQueryScRsp = 3840 + TextJoinBatchSaveScRsp = 3848 + TextJoinBatchSaveCsReq = 3876 + TextJoinQueryCsReq = 3831 + StartTrackPhotoStageScRsp = 7559 + QuitTrackPhotoStageScRsp = 7553 + GetTrackPhotoActivityDataCsReq = 7552 + GetTrackPhotoActivityDataScRsp = 7555 + QuitTrackPhotoStageCsReq = 7556 + SettleTrackPhotoStageCsReq = 7554 + StartTrackPhotoStageCsReq = 7551 + SettleTrackPhotoStageScRsp = 7557 + TrainPartyAddBuildDynamicBuffScRsp = 8091 + TrainPartyBuildStartStepScRsp = 8046 + TrainPartyUseCardScRsp = 8040 + TrainPartyTakeBuildLevelAwardScRsp = 8075 + TrainPartyTakeBuildLevelAwardCsReq = 8030 + TrainPartyHandlePendingActionCsReq = 8072 + TrainPartyLeaveCsReq = 8042 + TrainPartyBuildDiyScRsp = 8060 + TrainPartyGamePlayStartScRsp = 8093 + TrainPartySyncUpdateScNotify = 8022 + TrainPartyEnterScRsp = 8033 + TrainPartyBuildDiyCsReq = 8083 + TrainPartyAddBuildDynamicBuffCsReq = 8051 + TrainPartyBuildStartStepCsReq = 8016 + TrainPartyGamePlaySettleNotify = 8025 + TrainPartyBuildingUpdateNotify = 8002 + TrainPartyGetDataScRsp = 8032 + TrainPartyMoveScNotify = 8076 + TrainPartyLeaveScRsp = 8077 + TrainPartyUpdatePosEnvCsReq = 8084 + TrainPartyGetDataCsReq = 8095 + TrainPartyUseCardCsReq = 8031 + TrainPartySettleNotify = 8071 + TrainPartyUpdatePosEnvScRsp = 8037 + TrainPartyGamePlayStartCsReq = 8011 + TrainPartyEnterCsReq = 8043 + TrainPartyHandlePendingActionScRsp = 8085 + ShowNewSupplementVisitorCsReq = 3772 + TrainVisitorRewardSendNotify = 3748 + GetTrainVisitorRegisterCsReq = 3771 + ShowNewSupplementVisitorScRsp = 3785 + TakeTrainVisitorUntakenBehaviorRewardCsReq = 3722 + GetTrainVisitorBehaviorScRsp = 3740 + TrainVisitorBehaviorFinishScRsp = 3732 + GetTrainVisitorBehaviorCsReq = 3731 + TakeTrainVisitorUntakenBehaviorRewardScRsp = 3756 + GetTrainVisitorRegisterScRsp = 3752 + TrainVisitorBehaviorFinishCsReq = 3795 + TrainRefreshTimeNotify = 3776 + TravelBrochureSelectMessageCsReq = 6476 + TravelBrochurePageResetCsReq = 6443 + TravelBrochureRemovePasterCsReq = 6422 + TravelBrochureRemovePasterScRsp = 6456 + TravelBrochureGetDataScRsp = 6432 + TravelBrochureGetPasterScNotify = 6416 + TravelBrochureApplyPasterCsReq = 6471 + TravelBrochureApplyPasterListCsReq = 6442 + TravelBrochureSetCustomValueCsReq = 6483 + TravelBrochureUpdatePasterPosCsReq = 6472 + TravelBrochureGetDataCsReq = 6495 + TravelBrochureSetPageDescStatusScRsp = 6439 + TravelBrochureApplyPasterListScRsp = 6477 + TravelBrochurePageResetScRsp = 6433 + TravelBrochureUpdatePasterPosScRsp = 6485 + TravelBrochureSetCustomValueScRsp = 6460 + TravelBrochureSelectMessageScRsp = 6448 + TravelBrochurePageUnlockScNotify = 6431 + TravelBrochureApplyPasterScRsp = 6452 + TravelBrochureSetPageDescStatusCsReq = 6402 + TreasureDungeonDataScNotify = 4495 + QuitTreasureDungeonCsReq = 4458 + UseTreasureDungeonItemCsReq = 4442 + OpenTreasureDungeonGridScRsp = 4460 + OpenTreasureDungeonGridCsReq = 4483 + TreasureDungeonFinishScNotify = 4432 + UseTreasureDungeonItemScRsp = 4477 + InteractTreasureDungeonGridCsReq = 4443 + GetTreasureDungeonActivityDataCsReq = 4472 + GetTreasureDungeonActivityDataScRsp = 4485 + EnterTreasureDungeonScRsp = 4446 + EnterTreasureDungeonCsReq = 4416 + InteractTreasureDungeonGridScRsp = 4433 + FightTreasureDungeonMonsterCsReq = 4402 + FightTreasureDungeonMonsterScRsp = 4439 + QuitTreasureDungeonScRsp = 4421 + FinishTutorialGuideCsReq = 1672 + FinishTutorialScRsp = 1656 + GetTutorialGuideScRsp = 1640 + UnlockTutorialCsReq = 1676 + FinishTutorialCsReq = 1622 + GetTutorialCsReq = 1695 + GetTutorialGuideCsReq = 1631 + GetTutorialScRsp = 1632 + FinishTutorialGuideScRsp = 1685 + UnlockTutorialGuideScRsp = 1652 + UnlockTutorialScRsp = 1648 + UnlockTutorialGuideCsReq = 1671 + SetCurWaypointScRsp = 440 + GetWaypointScRsp = 432 + GetWaypointCsReq = 495 + TakeChapterRewardScRsp = 422 + SetCurWaypointCsReq = 431 + GetChapterScRsp = 448 + WaypointShowNewCsNotify = 471 + GetChapterCsReq = 476 + TakeChapterRewardCsReq = 452 + GetWolfBroGameDataCsReq = 6543 + WolfBroGameExplodeMonsterScRsp = 6526 + ArchiveWolfBroGameScRsp = 6537 + ArchiveWolfBroGameCsReq = 6502 + WolfBroGameActivateBulletCsReq = 6544 + GetWolfBroGameDataScRsp = 6509 + RestoreWolfBroGameArchiveCsReq = 6536 + WolfBroGameActivateBulletScRsp = 6532 + QuitWolfBroGameScRsp = 6515 + WolfBroGameExplodeMonsterCsReq = 6523 + WolfBroGameDataChangeScNotify = 6545 + WolfBroGameUseBulletCsReq = 6507 + QuitWolfBroGameCsReq = 6527 + WolfBroGamePickupBulletScRsp = 6520 + WolfBroGamePickupBulletCsReq = 6540 + RestoreWolfBroGameArchiveScRsp = 6517 + StartWolfBroGameScRsp = 6546 + StartWolfBroGameCsReq = 6504 + WolfBroGameUseBulletScRsp = 6550 + WorldUnlockScRsp = 7627 + WorldUnlockCsReq = 7626 + +def get_key_by_value(value): + for key, enum_value in CmdID.__members__.items(): + if enum_value == value: + return str(key) + return None \ No newline at end of file diff --git a/rail_proto/lib.py b/rail_proto/lib.py new file mode 100644 index 0000000..0a428b8 --- /dev/null +++ b/rail_proto/lib.py @@ -0,0 +1,23969 @@ +# Generated by the protocol buffer compiler. DO NOT EDIT! +# sources: StarRail.proto +# plugin: python-betterproto +from dataclasses import dataclass +from typing import Dict, List + +import betterproto + +class AvatarSlotType(betterproto.Enum): + AVATAR_SLOT_1 = 0 + AVATAR_SLOT_2 = 1 + AVATAR_SLOT_3 = 2 + + +class ItemType(betterproto.Enum): + ITEM_TYPE_NONE = 0 + ITEM_AVATAR_CARD = 1 + ITEM_EQUIPMENT = 2 + ITEM_MATERIAL = 3 + ITEM_AVATAR_EXP = 4 + ITEM_RELIC = 5 + + +class VirtualItemType(betterproto.Enum): + VIRTUAL_ITEM_NONE = 0 + VIRTUAL_ITEM_HCOIN = 1 + VIRTUAL_ITEM_SCOIN = 2 + VIRTUAL_ITEM_MCOIN = 3 + VIRTUAL_ITEM_STAMINA = 11 + VIRTUAL_ITEM_RESERVE_STAMINA = 12 + VIRTUAL_ITEM_AVATAR_EXP = 21 + VIRTUAL_ITEM_EXP = 22 + VIRTUAL_ITEM_DAILY_ACTIVE_POINT = 23 + VIRTUAL_ITEM_MP_MAX = 24 + VIRTUAL_ITEM_PLAYER_RETURN_POINT = 25 + VIRTUAL_ITEM_BATTLE_COLLEGE_POINT = 26 + VIRTUAL_ITEM_ROGUE_COIN = 31 + VIRTUAL_ITEM_ROGUE_TALENT_COIN = 32 + VIRTUAL_ITEM_ROGUE_REWARD_KEY = 33 + VIRTUAL_ITEM_ACHIEVEMENT_EXP = 41 + VIRTUAL_ITEM_BP_EXP = 51 + VIRTUAL_ITEM_BP_REAL_EXP = 52 + VIRTUAL_ITEM_MUSEUM_FUNDS = 53 + VIRTUAL_TRAINPARTY_BUILDING_FUNDS = 54 + VIRTUAL_TRAINPARTY_AREA_UNLOCK_COIN = 55 + VIRTUAL_TRAINPARTY_MOBILITY = 56 + VIRTUAL_ITEM_WARRIOR_EXP = 190 + VIRTUAL_ITEM_ROGUE_EXP = 191 + VIRTUAL_ITEM_MAGE_EXP = 192 + VIRTUAL_ITEM_SHAMAN_EXP = 193 + VIRTUAL_ITEM_WARLOCK_EXP = 194 + VIRTUAL_ITEM_KNIGHT_EXP = 195 + VIRTUAL_ITEM_PRIEST_EXP = 196 + VIRTUAL_ITEM_PUNK_LORD_POINT = 100000 + VIRTUAL_ITEM_GAMEPLAY_COUNTER_MONSTER_SNEAK_VISION = 280001 + VIRTUAL_ITEM_GAMEPLAY_COUNTER_WOLF_BRO_BULLET = 280002 + VIRTUAL_ITEM_ALLEY_FUNDS = 281001 + VIRTUAL_ITEM_ROGUE_PUMAN_COUPON = 281012 + VIRTUAL_ITEM_MONTH_CARD = 300101 + VIRTUAL_ITEM_BP_NORMAL = 300102 + VIRTUAL_ITEM_BP_DELUXE = 300103 + VIRTUAL_ITEM_BP_UPGRADE = 300104 + VIRTUAL_ITEM_HELIOBUS_FANS = 281002 + VIRTUAL_ITEM_SPACE_ZOO_HYBRID_ITEM = 281003 + VIRTUAL_ITEM_SPACE_ZOO_EXP_POINT = 281004 + VIRTUAL_ITEM_ROGUE_NOUS_TALENT_COIN = 281013 + VIRTUAL_ITEM_EVOLVE_BUILD_COIN = 281019 + VIRTUAL_ITEM_DRINK_MAKER_TIP = 281005 + VIRTUAL_ITEM_MONOPOLY_DICE = 281014 + VIRTUAL_ITEM_MONOPOLY_COIN = 281015 + VIRTUAL_ITEM_MONOPOLY_CHEATDICE = 281016 + VIRTUAL_ITEM_MONOPOLY_REROLL = 281017 + VIRTUAL_ITEM_ROGUE_TOURN_PERMANENT_TALENT_COIN = 281018 + VIRTUAL_ITEM_ROGUE_TOURN_SEASON_TALENT_COIN = 281020 + VIRTUAL_ITEM_ROGUE_TOURN_EXP = 281022 + VIRTUAL_ITEM_MATCHTHREE_COIN = 281024 + VIRTUAL_ITEM_SWORD_TRAINING_SKILL_POINT = 281023 + VIRTUAL_ITEM_FIGHT_FEST_COIN = 281025 + VIRTUAL_ITEM_ROGUE_MAGIC_TALENT_COIN = 281026 + VIRTUAL_ITEM_EVOLVE_BUILD_SC_COIN = 281027 + VIRTUAL_ITEM_EVOLVE_BUILD_REWARD_EXP = 281028 + + +class GameplayCounterType(betterproto.Enum): + GAMEPLAY_COUNTER_NONE = 0 + GAMEPLAY_COUNTER_MONSTER_SNEAK_VISION = 280001 + + +class BlackLimitLevel(betterproto.Enum): + BLACK_LIMIT_LEVEL_ALL = 0 + + +class AreaType(betterproto.Enum): + AREA_NONE = 0 + AREA_CN = 1 + AREA_JP = 2 + AREA_ASIA = 3 + AREA_WEST = 4 + AREA_KR = 5 + AREA_OVERSEAS = 6 + + +class EntityType(betterproto.Enum): + ENTITY_NONE = 0 + ENTITY_AVATAR = 1 + ENTITY_MONSTER = 2 + ENTITY_NPC = 3 + ENTITY_PROP = 4 + ENTITY_TRIGGER = 5 + ENTITY_ENV = 6 + ENTITY_SUMMON_UNIT = 7 + + +class LanguageType(betterproto.Enum): + LANGUAGE_NONE = 0 + LANGUAGE_SC = 1 + LANGUAGE_TC = 2 + LANGUAGE_EN = 3 + LANGUAGE_KR = 4 + LANGUAGE_JP = 5 + LANGUAGE_FR = 6 + LANGUAGE_DE = 7 + LANGUAGE_ES = 8 + LANGUAGE_PT = 9 + LANGUAGE_RU = 10 + LANGUAGE_TH = 11 + LANGUAGE_VI = 12 + LANGUAGE_ID = 13 + + +class PlatformType(betterproto.Enum): + EDITOR = 0 + IOS = 1 + ANDROID = 2 + PC = 3 + WEB = 4 + WAP = 5 + PS4 = 6 + NINTENDO = 7 + CLOUD_ANDROID = 8 + CLOUD_PC = 9 + CLOUD_IOS = 10 + PS5 = 11 + MAC = 12 + CLOUD_MAC = 13 + CLOUD_WEB_ANDROID = 20 + CLOUD_WEB_IOS = 21 + CLOUD_WEB_PC = 22 + CLOUD_WEB_MAC = 23 + CLOUD_WEB_TOUCH = 24 + CLOUD_WEB_KEYBOARD = 25 + CLOUD_DOUYIN_IOS = 27 + CLOUD_DOUYIN_ANDROID = 28 + + +class ReloginType(betterproto.Enum): + NO_KICK = 0 + FORCE_KICK = 1 + IDLE_KICK = 2 + SILENCE = 3 + + +class AvatarType(betterproto.Enum): + AVATAR_TYPE_NONE = 0 + AVATAR_TRIAL_TYPE = 1 + AVATAR_LIMIT_TYPE = 2 + AVATAR_FORMAL_TYPE = 3 + AVATAR_ASSIST_TYPE = 4 + AVATAR_AETHER_DIVIDE_TYPE = 5 + AVATAR_UPGRADE_AVAILABLE_TYPE = 6 + + +class MultiPathAvatarType(betterproto.Enum): + MultiPathAvatarTypeNone = 0 + Mar_7thKnightType = 1001 + Mar_7thRogueType = 1224 + BoyWarriorType = 8001 + GirlWarriorType = 8002 + BoyKnightType = 8003 + GirlKnightType = 8004 + BoyShamanType = 8005 + GirlShamanType = 8006 + BoyMemoryType = 8007 + GirlMemoryType = 8008 + + +class Gender(betterproto.Enum): + GenderNone = 0 + GenderMan = 1 + GenderWoman = 2 + + +class ProductType(betterproto.Enum): + PRODUCT_NONE = 0 + PRODUCT_NORMAL = 1 + PRODUCT_LIMIT = 2 + PRODUCT_LIMIT_NO_PAY = 3 + PRODUCT_NO_PROCESS_ORDER = 4 + + +class ProductGiftType(betterproto.Enum): + PRODUCT_GIFT_NONE = 0 + PRODUCT_GIFT_COIN = 1 + PRODUCT_GIFT_MONTH_CARD = 2 + PRODUCT_GIFT_BP_68 = 3 + PRODUCT_GIFT_BP_128 = 4 + PRODUCT_GIFT_BP68_UPGRADE_128 = 5 + PRODUCT_GIFT_POINT_CARD = 6 + PRODUCT_GIFT_PS_PRE_ORDER_1 = 7 + PRODUCT_GIFT_PS_PRE_ORDER_2 = 8 + PRODUCT_GIFT_GOOGLE_POINTS_100 = 9 + PRODUCT_GIFT_GOOGLE_POINTS_150 = 10 + PRODUCT_GIFT_PS_POINT_CARD_030 = 11 + PRODUCT_GIFT_PS_POINT_CARD_050 = 12 + PRODUCT_GIFT_PS_POINT_CARD_100 = 13 + PRODUCT_GIFT_PSN_PLUS = 14 + PRODUCT_GIFT_SINGLE_6 = 15 + PRODUCT_GIFT_DAILY_LOGIN_30 = 16 + PRODUCT_GIFT_APPLE_GIFT_CARD = 17 + PRODUCT_GIFT_FTC_UP_GACHA_TICKET_1 = 18 + PRODUCT_GIFT_FTC_UP_GACHA_TICKET_10 = 19 + PRODUCT_GIFT_FTC_NORMAL_GACHA_TICKET_1 = 20 + PRODUCT_GIFT_FTC_NORMAL_GACHA_TICKET_10 = 21 + + +class FeatureSwitchType(betterproto.Enum): + FEATURE_SWITCH_NONE = 0 + FEATURE_SWITCH_SHOP = 1 + FEATURE_SWITCH_LINEUP_NAME = 2 + FEATURE_SWITCH_RECHARGE_SHOP = 3 + FEATURE_SWITCH_NICKNAME = 4 + FEATURE_SWITCH_SIGNATURE = 5 + FEATURE_SWITCH_BATTLEPASS = 6 + FEATURE_SWITCH_PUNK_LORD = 7 + FEATURE_SWITCH_MONTHCARD_DAILY = 8 + FEATURE_SWITCH_PICTURE_SHARE = 9 + FEATURE_SWITCH_ROGUE = 10 + FEATURE_SWITCH_CHALLENGE = 11 + FEATURE_SWITCH_COCOON = 12 + FEATURE_SWITCH_RAID = 13 + FEATURE_SWITCH_MAZE_PLANE_EVENT = 14 + FEATURE_SWITCH_ACTIVITY_PANEL = 15 + FEATURE_SWITCH_MAILBOX = 16 + FEATURE_SWITCH_QUEST = 17 + FEATURE_SWITCH_GACHA = 18 + FEATURE_SWITCH_CHAT = 19 + FEATURE_SWITCH_MODIFY_FRIEND_ALIAS = 20 + FEATURE_SWITCH_USE_ITEM = 21 + FEATURE_SWITCH_ACTIVITY_SCHEDULE = 22 + FEATURE_SWITCH_FARM_ELEMENT = 23 + FEATURE_SWITCH_ACHIEVEMENT_LEVEL = 24 + FEATURE_SWITCH_DAILY_ACTIVE_LEVEL = 25 + FEATURE_SWITCH_PLAYER_RETURN = 26 + FEATURE_SWITCH_FIRST_SET_NICKNAME = 27 + FEATURE_SWITCH_MAIN_MISSION_REWARD = 28 + FEATURE_SWITCH_SUB_MISSION_REWARD = 29 + FEATURE_SWITCH_PAM_MISSION = 30 + FEATURE_SWITCH_DESTROY_ITEM = 32 + FEATURE_SWITCH_CONSUME_ITEM_TURN = 33 + FEATURE_SWITCH_ROGUE_MODIFIER = 34 + FEATURE_SWITCH_CHESS_ROGUE = 35 + FEATURE_SWITCH_CHESS_ROGUE_BOARD = 36 + FEATURE_SWITCH_ROLL_SHOP = 37 + FEATURE_SWITCH_H5_RETURN = 38 + FEATURE_SWITCH_OFFERING = 39 + FEATURE_SWITCH_SERVER_RED_POINT = 40 + FEATURE_SWITCH_MONOPOLY_OPTION_RATIO = 41 + FEATURE_SWITCH_MONOPOLY_GET_RAFFLE_TICKET = 42 + FEATURE_SWITCH_MONOPOLY_TAKE_RAFFLE_REWARD = 43 + FEATURE_SWITCH_CHALLENGE_RECOMMEND_LINEUP = 44 + FEATURE_SWITCH_PSN_MEMBER_SHIP_CHECK = 45 + FEATURE_SWITCH_PLAYER_BOARD_DEVELOPMENT = 46 + FEATURE_SWITCH_PVP = 47 + FEATURE_SWITCH_ROGUE_MODE = 48 + FEATURE_SWITCH_ROGUE_TOURN_UGC = 49 + FEATURE_SWITCH_RELIC_FILTER_PLAN_NAME = 50 + FEATURE_SWITCH_MAZE_ITEM_USE_BUFF_DROP = 51 + FEATURE_SWITCH_RED_DOT = 52 + FEATURE_SWITCH_GAME_STATE_SERVICE = 53 + FEATURE_SWITCH_BENEFIT_INDEX = 54 + FEATURE_SWITCH_ROGUE_TOURN_BUILD_REF = 55 + FEATURE_SWITCH_PRE_AVATAR_SET_GROWTH_TARGET = 56 + FEATURE_SWITCH_IMPORT_RELIC_FILTER_PLAN = 58 + FEATURE_SWITCH_GACHA_DECIDE_ITEM = 59 + FEATURE_SWITCH_ITEM_SYNC = 60 + FEATURE_SWITCH_RECHARGE_BENEFIT = 61 + FEATURE_SWITCH_RECHARGE_GIFT = 62 + FEATURE_SWITCH_ROGUE_TOURN_BUILD_REF_SHARE_CODE = 63 + FEATURE_SWITCH_GACHA_AVATAR_TOAST = 64 + FEATURE_SWITCH_ROGUE_TOURN_BUILD_REF_SHARE_CODE_RENAME = 65 + FEATURE_SWITCH_RELIC_SMART_DISCARD = 66 + FEATURE_SWITCH_PLANETFES_SOCIAL = 67 + + +class SecretKeyType(betterproto.Enum): + SECRET_KEY_NONE = 0 + SECRET_KEY_SERVER_CHECK = 1 + SECRET_KEY_VIDEO = 2 + SECRET_KEY_BATTLE_TIME = 3 + + +class ReplayType(betterproto.Enum): + REPLAY_TYPE_NONE = 0 + REPLAY_TYPE_PUNK_LORD = 1 + + +class PunkLordShareType(betterproto.Enum): + PUNK_LORD_SHARE_TYPE_NONE = 0 + PUNK_LORD_SHARE_TYPE_FRIEND = 1 + PUNK_LORD_SHARE_TYPE_ALL = 2 + + +class PunkLordAttackerStatus(betterproto.Enum): + PUNK_LORD_ATTACKER_STATUS_NONE = 0 + PUNK_LORD_ATTACKER_STATUS_ATTACKED = 1 + PUNK_LORD_ATTACKER_STATUS_ATTACKING = 2 + PUNK_LORD_ATTACKER_STATUS_ATTACKED_AND_ATTACKING = 3 + + +class PunkLordMonsterInfoNotifyReason(betterproto.Enum): + PUNK_LORD_MONSTER_INFO_NOTIFY_REASON_NONE = 0 + PUNK_LORD_MONSTER_INFO_NOTIFY_REASON_ENTER_RAID = 1 + PUNK_LORD_MONSTER_INFO_NOTIFY_REASON_BATTLE_END = 2 + PUNK_LORD_MONSTER_INFO_NOTIFY_REASON_LEAVE_RAID = 3 + + +class ChatType(betterproto.Enum): + CHAT_TYPE_NONE = 0 + CHAT_TYPE_PRIVATE = 1 + CHAT_TYPE_GROUP = 2 + + +class MsgType(betterproto.Enum): + MSG_TYPE_NONE = 0 + MSG_TYPE_CUSTOM_TEXT = 1 + MSG_TYPE_EMOJI = 2 + MSG_TYPE_INVITE = 3 + MSG_TYPE_PLANET_FES = 4 + + +class PlanetFesType(betterproto.Enum): + PLANET_FES_MSG_CONTENT_NONE = 0 + PLANET_FES_MSG_CONTENT_APPLY_REQ = 1 + PLANET_FES_MSG_CONTENT_PIECE_OFFERED = 2 + + +class ShieldType(betterproto.Enum): + SHIELD_TYPE_NONE = 0 + SHIELD_TYPE_REPLACE = 1 + SHIELD_TYPE_SHIED = 2 + + +class FuncUnlockIdType(betterproto.Enum): + FUNC_UNLOCK_ID_NONE = 0 + FUNC_UNLOCK_ID_RELIC = 403 + FUNC_UNLOCK_ID_RELIC_NUM = 404 + FUNC_UNLOCK_ID_EQUIPMENT = 401 + FUNC_UNLOCK_ID_SKILLTREE = 402 + FUNC_UNLOCK_ID_GACHA = 2300 + FUNC_UNLOCK_ID_EXPEDITION = 3100 + FUNC_UNLOCK_ID_COMPOSE = 4100 + FUNC_UNLOCK_ID_FIGHTACTIVITY = 3700 + + +class AssistAvatarType(betterproto.Enum): + ASSIST_AVATAR_UNKNOW = 0 + ASSIST_AVATAR_LEVEL = 1 + ASSIST_AVATAR_RANK = 2 + + +class DevelopmentType(betterproto.Enum): + DEVELOPMENT_NONE = 0 + DEVELOPMENT_ROGUE_COSMOS = 1 + DEVELOPMENT_ROGUE_CHESS = 2 + DEVELOPMENT_ROGUE_CHESS_NOUS = 3 + DEVELOPMENT_MEMORY_CHALLENGE = 4 + DEVELOPMENT_STORY_CHALLENGE = 5 + DEVELOPMENT_UNLOCK_AVATAR = 6 + DEVELOPMENT_UNLOCK_EQUIPMENT = 7 + DEVELOPMENT_ACTIVITY_START = 8 + DEVELOPMENT_ACTIVITY_END = 9 + DEVELOPMENT_BOSS_CHALLENGE = 10 + DEVELOPMENT_ROGUE_TOURN = 11 + DEVELOPMENT_ROGUE_TOURN_WEEK = 12 + DEVELOPMENT_ROGUE_MAGIC = 13 + + +class PlayingState(betterproto.Enum): + PLAYING_STATE_NONE = 0 + PLAYING_ROGUE_COSMOS = 1 + PLAYING_ROGUE_CHESS = 2 + PLAYING_ROGUE_CHESS_NOUS = 3 + PLAYING_CHALLENGE_MEMORY = 4 + PLAYING_CHALLENGE_STORY = 5 + PLAYING_CHALLENGE_BOSS = 6 + PLAYING_ROGUE_TOURN = 7 + PLAYING_ROGUE_MAGIC = 8 + + +class MatchRoomCharacterType(betterproto.Enum): + MatchRoomCharacter_None = 0 + MatchRoomCharacter_Leader = 1 + MatchRoomCharacter_Member = 2 + MatchRoomCharacter_Watcher = 3 + + +class MatchRoomCharacterStatus(betterproto.Enum): + MatchRoomCharacterStatus_None = 0 + MatchRoomCharacterStatus_Idle = 1 + MatchRoomCharacterStatus_Operating = 2 + MatchRoomCharacterStatus_Ready = 3 + MatchRoomCharacterStatus_Fighting = 4 + MatchRoomCharacterStatus_Watching = 5 + + +class MGECFLOEOEG(betterproto.Enum): + PLANET_FES_CARD_PIECE_APPLY_PERMISSION_REVIEW = 0 + PLANET_FES_CARD_PIECE_APPLY_PERMISSION_FREE = 1 + PLANET_FES_CARD_PIECE_PERMISSION_BAN = 2 + + +class GHANGCBOEMC(betterproto.Enum): + PLANET_FES_CARD_PIECE_INTERACT_APPLYING = 0 + PLANET_FES_CARD_PIECE_INTERACT_OFFERED = 1 + PLANET_FES_CARD_PIECE_INTERACT_OFFER_TAKEN = 2 + PLANET_FES_CARD_PIECE_INTERACT_APPLY_CANCELD = 3 + PLANET_FES_CARD_PIECE_INTERACT_APPLY_COMPENSATED = 4 + + +class IJHBCBEOPFE(betterproto.Enum): + PLANET_FES_CARD_PIECE_OFFER_SOURCE_REVIEW_APPLY = 0 + PLANET_FES_CARD_PIECE_OFFER_SOURCE_FREE_APPLY = 1 + PLANET_FES_CARD_PIECE_OFFER_SOURCE_GIVE = 2 + + +class DLLLEANDAIH(betterproto.Enum): + FRIEND_RECOMMEND_LINEUP_TYPE_NONE = 0 + FRIEND_RECOMMEND_LINEUP_TYPE_CHALLENGE = 1 + FRIEND_RECOMMEND_LINEUP_TYPE_LOCAL_LEGEND = 2 + + +class BattleCheckStrategyType(betterproto.Enum): + BATTLE_CHECK_STRATEGY_IDENTICAL = 0 + BATTLE_CHECK_STRATEGY_SERVER = 1 + BATTLE_CHECK_STRATEGY_CLIENT = 2 + + +class BattleCheckResultType(betterproto.Enum): + BATTLE_CHECK_RESULT_SUCC = 0 + BATTLE_CHECK_RESULT_FAIL = 1 + BATTLE_CHECK_RESULT_PASS = 2 + + +class BattleModuleType(betterproto.Enum): + BATTLE_MODULE_MAZE = 0 + BATTLE_MODULE_CHALLENGE = 1 + BATTLE_MODULE_COCOON = 2 + BATTLE_MODULE_ROGUE = 3 + BATTLE_MODULE_CHALLENGE_ACTIVITY = 4 + BATTLE_MODULE_TRIAL_LEVEL = 5 + BATTLE_MODULE_AETHER_DIVIDE = 6 + + +class AetherdivideSpiritLineupType(betterproto.Enum): + AETHERDIVIDE_SPIRIT_LINEUP_NONE = 0 + AETHERDIVIDE_SPIRIT_LINEUP_NORMAL = 1 + AETHERDIVIDE_SPIRIT_LINEUP_TRIAL = 2 + + +class BattleTargetType(betterproto.Enum): + BATTLE_TARGET_TYPE_NONE = 0 + BATTLE_TARGET_TYPE_SCORE = 1 + BATTLE_TARGET_TYPE_ACHIEVEMENT = 2 + BATTLE_TARGET_TYPE_RAID = 3 + BATTLE_TARGET_TYPE_CHALLENGE_SCORE = 4 + BATTLE_TARGET_TYPE_COMMON = 5 + BATTLE_TARGET_TYPE_CLIENT_ACHIEVEMENT = 6 + + +class DeathSource(betterproto.Enum): + UNKNOWN = 0 + KILLED_BY_OTHERS = 1 + KILLED_BY_SELF = 2 + ESCAPE = 3 + + +class BattleTag(betterproto.Enum): + TAG_NONE = 0 + TAG_HIDE_NPC_MONSTER = 1 + + +class HEMBNDJAFDA(betterproto.Enum): + NORMAL_CREATE = 0 + FORM_CHANGE = 1 + + +class BattleEndReason(betterproto.Enum): + BATTLE_END_REASON_NONE = 0 + BATTLE_END_REASON_ALL_DIE = 1 + BATTLE_END_REASON_TURN_LIMIT = 2 + + +class BattleStaticticEventType(betterproto.Enum): + BATTLE_STATICTIC_EVENT_NONE = 0 + BATTLE_STATICTIC_EVENT_TREASURE_DUNGEON_ADD_EXPLORE = 1 + BATTLE_STATICTIC_EVENT_TREASURE_DUNGEON_OPEN_GRID = 2 + BATTLE_STATICTIC_EVENT_TREASURE_DUNGEON_PICKUP_ITEM = 3 + BATTLE_STATICTIC_EVENT_TREASURE_DUNGEON_USE_BUFF = 4 + BATTLE_STATICTIC_EVENT_TELEVISION_ACTIVITY_UPDATE_MAZE_BUFF_LAYER = 5 + BATTLE_STATICTIC_EVENT_ROGUE_TOURN_TITAN_EXTRA_COIN = 6 + BATTLE_STATICTIC_EVENT_ROGUE_TOURN_TITAN_EXTRA_COIN_TIMES = 7 + + +class BOJGAKMDPDL(betterproto.Enum): + EVOLVE_BUILD_FUNC_NONE = 0 + EVOLVE_BUILD_FUNC_GEAR_RESET = 1 + EVOLVE_BUILD_FUNC_GEAR_REMOVE = 2 + EVOLVE_BUILD_FUNC_GEAR_SKIP = 3 + EVOLVE_BUILD_FUNC_CARD_RESET = 4 + + +class JEGLEIKMNCL(betterproto.Enum): + kNone = 0 + kkillEliteMonsterNum = 1 + kkillMonsterNum = 2 + + +class BattleEndStatus(betterproto.Enum): + BATTLE_END_NONE = 0 + BATTLE_END_WIN = 1 + BATTLE_END_LOSE = 2 + BATTLE_END_QUIT = 3 + + +class FightGameMode(betterproto.Enum): + FIGHT_GAME_MODE_NONE = 0 + FIGHT_GAME_MODE_MATCH3 = 1 + FIGHT_GAME_MODE_MARBLE = 2 + + +class FightKickoutType(betterproto.Enum): + FIGHT_KICKOUT_UNKNOWN = 0 + FIGHT_KICKOUT_BLACK = 1 + FIGHT_KICKOUT_BY_GM = 2 + FIGHT_KICKOUT_TIMEOUT = 3 + FIGHT_KICKOUT_SESSION_RESET = 4 + + +class LobbyCharacterType(betterproto.Enum): + LobbyCharacter_None = 0 + LobbyCharacter_Leader = 1 + LobbyCharacter_Member = 2 + LobbyCharacter_Watcher = 3 + + +class LobbyCharacterStatus(betterproto.Enum): + LobbyCharacterStatus_None = 0 + LobbyCharacterStatus_Idle = 1 + LobbyCharacterStatus_Operating = 2 + LobbyCharacterStatus_Ready = 3 + LobbyCharacterStatus_Fighting = 4 + LobbyCharacterStatus_Watching = 5 + LobbyCharacterStatus_Matching = 6 + LobbyCharacterStatus_LobbyStartFight = 7 + + +class LobbyModifyType(betterproto.Enum): + LobbyModifyType_None = 0 + LobbyModifyType_Idle = 1 + LobbyModifyType_Ready = 2 + LobbyModifyType_Operating = 3 + LobbyModifyType_CancelMatch = 4 + LobbyModifyType_Match = 5 + LobbyModifyType_QuitLobby = 6 + LobbyModifyType_KickOut = 7 + LobbyModifyType_TimeOut = 8 + LobbyModifyType_JoinLobby = 9 + LobbyModifyType_LobbyDismiss = 10 + LobbyModifyType_MatchTimeOut = 11 + LobbyModifyType_FightStart = 12 + LobbyModifyType_Logout = 13 + LobbyModifyType_FightEnd = 14 + LobbyModifyType_FightRoomDestroyInInit = 15 + LobbyModifyType_LobbyStartFight = 16 + LobbyModifyType_LobbyStartFightTimeout = 17 + + +class FightRoomDestroyReason(betterproto.Enum): + FIGHT_ROOM_DESTROY_REASON_NONE = 0 + FIGHT_ROOM_DESTROY_REASON_SVR_STOP = 1 + FIGHT_ROOM_DESTROY_REASON_GAME_END = 2 + + +class Match3FinishReason(betterproto.Enum): + MATCH3_FINISH_REASON_DEFAULT = 0 + MATCH3_FINISH_REASON_LEAVE = 1 + MATCH3_FINISH_REASON_DIE = 2 + MATCH3_FINISH_REASON_GAMEEND = 3 + MATCH3_FINISH_REASON_KICKOUT = 4 + + +class MatchUnitType(betterproto.Enum): + MATCH_UNIT_TYPE_NONE = 0 + MATCH_UNIT_TYPE_NORMAL = 1 + MATCH_UNIT_TYPE_ROBOT = 2 + MATCH_UNIT_TYPE_GM = 3 + + +class FFJPPNGGLFF(betterproto.Enum): + FIGHT_PLAYER_RESULT_NONE = 0 + FIGHT_PLAYER_RESULT_WIN = 1 + FIGHT_PLAYER_RESULT_FAIL = 2 + FIGHT_PLAYER_RESULT_DRAW = 3 + + +class IMAONMHILNE(betterproto.Enum): + LOBBY_INTERACT_TYPE_NONE = 0 + LOBBY_INTERACT_TYPE_REMIND_PREPARE = 1 + +class Retcode(betterproto.Enum): + RET_SUCC = 0 + RET_FAIL = 1 + RET_SERVER_INTERNAL_ERROR = 2 + RET_TIMEOUT = 3 + RET_REPEATED_REQ = 4 + RET_REQ_PARA_INVALID = 5 + RET_PLAYER_DATA_ERROR = 6 + RET_PLAYER_CLIENT_PAUSED = 7 + RET_FUNC_CHECK_FAILED = 8 + RET_FEATURE_SWITCH_CLOSED = 9 + RET_FREQ_OVER_LIMIT = 10 + RET_SYSTEM_BUSY = 11 + RET_PLAYER_NOT_ONLINE = 12 + RET_OPERATION_IN_CD = 13 + RET_REPEATE_LOGIN = 1000 + RET_RETRY_LOGIN = 1001 + RET_WAIT_LOGIN = 1002 + RET_NOT_IN_WHITE_LIST = 1003 + RET_IN_BLACK_LIST = 1004 + RET_ACCOUNT_VERIFY_ERROR = 1005 + RET_ACCOUNT_PARA_ERROR = 1006 + RET_ANTI_ADDICT_LOGIN = 1007 + RET_CHECK_SUM_ERROR = 1008 + RET_REACH_MAX_PLAYER_NUM = 1009 + RET_ALREADY_REGISTERED = 1010 + RET_GENDER_ERROR = 1011 + SET_NICKNAME_RET_CALLBACK_PROCESSING = 1012 + RET_IN_GM_BIND_ACCESS = 1013 + RET_QUEST_REWARD_ALREADY_TAKEN = 1100 + RET_QUEST_NOT_ACCEPT = 1101 + RET_QUEST_NOT_FINISH = 1102 + RET_QUEST_STATUS_ERROR = 1103 + RET_ACHIEVEMENT_LEVEL_NOT_REACH = 1104 + RET_ACHIEVEMENT_LEVEL_ALREADY_TAKEN = 1105 + RET_AVATAR_NOT_EXIST = 1200 + RET_AVATAR_RES_EXP_NOT_ENOUGH = 1201 + RET_AVATAR_EXP_REACH_PROMOTION_LIMIT = 1202 + RET_AVATAR_REACH_MAX_PROMOTION = 1203 + RET_SKILLTREE_CONFIG_NOT_EXIST = 1204 + RET_SKILLTREE_ALREADY_UNLOCK = 1205 + RET_SKILLTREE_PRE_LOCKED = 1206 + RET_SKILLTREE_LEVEL_NOT_MEET = 1207 + RET_SKILLTREE_RANK_NOT_MEET = 1208 + RET_AVATAR_DRESS_NO_EQUIPMENT = 1209 + RET_AVATAR_EXP_ITEM_NOT_EXIST = 1210 + RET_SKILLTREE_POINT_LOCKED = 1211 + RET_SKILLTREE_POINT_LEVEL_UPGRADE_NOT_MATCH = 1212 + RET_SKILLTREE_POINT_LEVEL_REACH_MAX = 1213 + RET_WORLD_LEVEL_NOT_MEET = 1214 + RET_PLAYER_LEVEL_NOT_MEET = 1215 + RET_AVATAR_RANK_NOT_MATCH = 1216 + RET_AVATAR_RANK_REACH_MAX = 1217 + RET_HERO_BASIC_TYPE_NOT_MATCH = 1218 + RET_AVATAR_PROMOTION_NOT_MEET = 1219 + RET_PROMOTION_REWARD_CONFIG_NOT_EXIST = 1220 + RET_PROMOTION_REWARD_ALREADY_TAKEN = 1221 + RET_AVATAR_SKIN_ITEM_NOT_EXIST = 1222 + RET_AVATAR_SKIN_ALREADY_DRESSED = 1223 + RET_AVATAR_NOT_DRESS_SKIN = 1224 + RET_AVATAR_SKIN_NOT_MATCH_AVATAR = 1225 + RET_AVATAR_PATH_NOT_MATCH = 1226 + RET_ITEM_NOT_EXIST = 1300 + RET_ITEM_COST_NOT_ENOUGH = 1301 + RET_ITEM_COST_TOO_MUCH = 1302 + RET_ITEM_NO_COST = 1303 + RET_ITEM_NOT_ENOUGH = 1304 + RET_ITEM_INVALID = 1305 + RET_ITEM_CONFIG_NOT_EXIST = 1306 + RET_SCOIN_NOT_ENOUGH = 1307 + RET_ITEM_REWARD_EXCEED_LIMIT = 1308 + RET_ITEM_INVALID_USE = 1309 + RET_ITEM_USE_CONFIG_NOT_EXIST = 1310 + RET_REWARD_CONFIG_NOT_EXIST = 1311 + RET_ITEM_EXCEED_LIMIT = 1312 + RET_ITEM_COUNT_INVALID = 1313 + RET_ITEM_USE_TARGET_TYPE_INVALID = 1314 + RET_ITEM_USE_SATIETY_FULL = 1315 + RET_ITEM_COMPOSE_NOT_EXIST = 1316 + RET_RELIC_COMPOSE_NOT_EXIST = 1317 + RET_ITEM_CAN_NOT_SELL = 1318 + RET_ITEM_SELL_EXCEDD_LIMIT = 1319 + RET_ITEM_NOT_IN_COST_LIST = 1320 + RET_ITEM_SPECIAL_COST_NOT_ENOUGH = 1321 + RET_ITEM_SPECIAL_COST_TOO_MUCH = 1322 + RET_ITEM_FORMULA_NOT_EXIST = 1323 + RET_ITEM_AUTO_GIFT_OPTIONAL_NOT_EXIST = 1324 + RET_RELIC_COMPOSE_RELIC_INVALID = 1325 + RET_RELIC_COMPOSE_MAIN_AFFIX_ID_INVALID = 1326 + RET_RELIC_COMPOSE_WRONG_FORMULA_TYPE = 1327 + RET_RELIC_COMPOSE_RELIC_NOT_EXIST = 1328 + RET_RELIC_COMPOSE_BLACK_GOLD_COUNT_INVALID = 1329 + RET_RELIC_COMPOSE_BLACK_GOLD_NOT_NEED = 1330 + RET_MONTH_CARD_CANNOT_USE = 1331 + RET_ITEM_REWARD_EXCEED_DISAPPEAR = 1332 + RET_ITEM_NEED_RECYCLE = 1333 + RET_ITEM_COMPOSE_EXCEED_LIMIT = 1334 + RET_ITEM_CAN_NOT_DESTROY = 1335 + RET_ITEM_ALREADY_MARK = 1336 + RET_ITEM_MARK_EXCEED_LIMIT = 1337 + RET_ITEM_NOT_MARK = 1338 + RET_ITEN_TURN_FOOD_NOT_SET = 1339 + RET_ITEM_TURN_FOOD_ALREADY_SET = 1340 + RET_ITEM_TURN_FOOD_CONSUME_TYPE_ERROR = 1341 + RET_ITEM_TURN_FOOD_SWITCH_ALREADY_OPEN = 1342 + RET_ITEM_TURN_FOOD_SWITCH_ALREADY_CLOSE = 1343 + RET_HCOIN_EXCHANGE_TOO_MUCH = 1344 + RET_ITEM_TURN_FOOD_SCENE_TYPE_ERROR = 1345 + RET_EQUIPMENT_ALREADY_DRESSED = 1350 + RET_EQUIPMENT_NOT_EXIST = 1351 + RET_EQUIPMENT_REACH_LEVEL_LIMIT = 1352 + RET_EQUIPMENT_CONSUME_SELF = 1353 + RET_EQUIPMENT_ALREADY_LOCKED = 1354 + RET_EQUIPMENT_ALREADY_UNLOCKED = 1355 + RET_EQUIPMENT_LOCKED = 1356 + RET_EQUIPMENT_SELECT_NUM_OVER_LIMIT = 1357 + RET_EQUIPMENT_RANK_UP_MUST_CONSUME_SAME_TID = 1358 + RET_EQUIPMENT_PROMOTION_REACH_MAX = 1359 + RET_EQUIPMENT_RANK_UP_REACH_MAX = 1360 + RET_EQUIPMENT_LEVEL_REACH_MAX = 1361 + RET_EQUIPMENT_EXCEED_LIMIT = 1362 + RET_RELIC_NOT_EXIST = 1363 + RET_RELIC_REACH_LEVEL_LIMIT = 1364 + RET_RELIC_CONSUME_SELF = 1365 + RET_RELIC_ALREADY_DRESSED = 1366 + RET_RELIC_LOCKED = 1367 + RET_RELIC_ALREADY_LOCKED = 1368 + RET_RELIC_ALREADY_UNLOCKED = 1369 + RET_RELIC_LEVEL_IS_NOT_ZERO = 1370 + RET_UNIQUE_ID_REPEATED = 1371 + RET_EQUIPMENT_LEVEL_NOT_MEET = 1372 + RET_EQUIPMENT_ITEM_NOT_IN_COST_LIST = 1373 + RET_EQUIPMENT_LEVEL_GREATER_THAN_ONE = 1374 + RET_EQUIPMENT_ALREADY_RANKED = 1375 + RET_RELIC_EXCEED_LIMIT = 1376 + RET_RELIC_ALREADY_DISCARDED = 1377 + RET_RELIC_ALREADY_UNDISCARDED = 1378 + RET_EQUIPMENT_BATCH_LOCK_TOO_FAST = 1379 + RET_RELIC_FILTER_PLAN_SLOT_EMPTY = 1380 + RET_RELIC_FILTER_PLAN_NUM_EXCEED_LIMIT = 1381 + RET_RELIC_FILTER_PLAN_NAME_UTF8_ERROR = 1382 + RET_RELIC_FILTER_PLAN_NAME_FORMAT_ERROR = 1383 + RET_RELIC_FILTER_PLAN_NO_CHANGE = 1384 + RET_RELIC_REFORGE_NOT_CONFIRMED = 1385 + RET_EQUIPMENT_ALREADY_LEVELUP = 1386 + RET_EQUIPMENT_RARITY_ERROR = 1387 + RET_LINEUP_INVALID_INDEX = 1400 + RET_LINEUP_INVALID_MEMBER_POS = 1401 + RET_LINEUP_SWAP_NOT_EXIST = 1402 + RET_LINEUP_AVATAR_ALREADY_IN = 1403 + RET_LINEUP_CREATE_AVATAR_ERROR = 1404 + RET_LINEUP_AVATAR_INIT_ERROR = 1405 + RET_LINEUP_NOT_EXIST = 1406 + RET_LINEUP_ONLY_ONE_MEMBER = 1407 + RET_LINEUP_SAME_LEADER_SLOT = 1408 + RET_LINEUP_NO_LEADER_SELECT = 1409 + RET_LINEUP_SWAP_SAME_SLOT = 1410 + RET_LINEUP_AVATAR_NOT_EXIST = 1411 + RET_LINEUP_TRIAL_AVATAR_CAN_NOT_QUIT = 1412 + RET_LINEUP_VIRTUAL_LINEUP_PLANE_NOT_MATCH = 1413 + RET_LINEUP_NOT_VALID_LEADER = 1414 + RET_LINEUP_SAME_INDEX = 1415 + RET_LINEUP_IS_EMPTY = 1416 + RET_LINEUP_NAME_FORMAT_ERROR = 1417 + RET_LINEUP_TYPE_NOT_MATCH = 1418 + RET_LINEUP_REPLACE_ALL_FAILED = 1419 + RET_LINEUP_NOT_ALLOW_EDIT = 1420 + RET_LINEUP_AVATAR_IS_ALIVE = 1421 + RET_LINEUP_ASSIST_HAS_ONLY_MEMBER = 1422 + RET_LINEUP_ASSIST_CANNOT_SWITCH = 1423 + RET_LINEUP_AVATAR_TYPE_INVALID = 1424 + RET_LINEUP_NAME_UTF8_ERROR = 1425 + RET_LINEUP_LEADER_LOCK = 1426 + RET_LINEUP_STORY_LINE_NOT_MATCH = 1427 + RET_LINEUP_AVATAR_LOCK = 1428 + RET_LINEUP_AVATAR_INVALID = 1429 + RET_LINEUP_AVATAR_ALREADY_INIT = 1430 + RET_LINEUP_LIMITED = 1431 + RET_MAIL_NOT_EXIST = 1700 + RET_MAIL_RANGE_INVALID = 1701 + RET_MAIL_MAIL_ID_INVALID = 1702 + RET_MAIL_NO_MAIL_TAKE_ATTACHMENT = 1703 + RET_MAIL_NO_MAIL_TO_DEL = 1704 + RET_MAIL_TYPE_INVALID = 1705 + RET_MAIL_PARA_INVALID = 1706 + RET_MAIL_ATTACHEMENT_INVALID = 1707 + RET_MAIL_TICKET_INVALID = 1708 + RET_MAIL_TICKET_REPEATED = 1709 + RET_STAGE_SETTLE_ERROR = 1800 + RET_STAGE_CONFIG_NOT_EXIST = 1801 + RET_STAGE_NOT_FOUND = 1802 + RET_STAGE_COCOON_PROP_NOT_VALID = 1804 + RET_STAGE_COCOON_WAVE_NOT_VALID = 1805 + RET_STAGE_PROP_ID_NOT_EQUAL = 1806 + RET_STAGE_COCOON_WAVE_OVER = 1807 + RET_STAGE_WEEK_COCOON_OVER_CNT = 1808 + RET_STAGE_COCOON_NOT_OPEN = 1809 + RET_STAGE_TRIAL_NOT_OPEN = 1810 + RET_STAGE_FARM_NOT_OPEN = 1811 + RET_STAGE_FARM_TYPE_ERROR = 1812 + RET_STAGE_FARM_SWEEP_CD = 1813 + RET_CHAPTER_LOCK = 1900 + RET_CHAPTER_CHALLENGE_NUM_NOT_ENOUGH = 1901 + RET_CHAPTER_REWARD_ID_NOT_EXIST = 1902 + RET_CHAPTER_REWARD_ALREADY_TAKEN = 1903 + RET_BATTLE_STAGE_NOT_MATCH = 2000 + RET_IN_BATTLE_NOW = 2001 + RET_BATTLE_CHEAT = 2002 + RET_BATTLE_FAIL = 2003 + RET_BATTLE_NO_LINEUP = 2004 + RET_BATTLE_LINEUP_EMPTY = 2005 + RET_BATTLE_VERSION_NOT_MATCH = 2006 + RET_BATTLE_QUIT_BY_SERVER = 2007 + RET_IN_BATTLE_CHECK = 2008 + RET_BATTLE_CHECK_NEED_RETRY = 2009 + RET_BATTLE_COST_TIME_CHECK_FAIL = 2010 + RET_LACK_EXCHANGE_STAMINA_TIMES = 2100 + RET_LACK_STAMINA = 2101 + RET_STAMINA_FULL = 2102 + RET_AUTHKEY_SIGN_TYPE_ERROR = 2103 + RET_AUTHKEY_SIGN_VER_ERROR = 2104 + RET_NICKNAME_FORMAT_ERROR = 2105 + RET_SENSITIVE_WORDS = 2106 + RET_LEVEL_REWARD_HAS_TAKEN = 2107 + RET_LEVEL_REWARD_LEVEL_ERROR = 2108 + RET_LANGUAGE_INVALID = 2109 + RET_NICKNAME_IN_CD = 2110 + RET_GAMEPLAY_BIRTHDAY_INVALID = 2111 + RET_GAMEPLAY_BIRTHDAY_ALREADY_SET = 2112 + RET_NICKNAME_UTF8_ERROR = 2113 + RET_NICKNAME_DIGIT_LIMIT_ERROR = 2114 + RET_SENSITIVE_WORDS_PLATFORM_ERROR = 2115 + RET_PLAYER_SETTING_TYPE_INVALID = 2116 + RET_MAZE_LACK_TICKET = 2201 + RET_MAZE_NOT_UNLOCK = 2202 + RET_MAZE_NO_ABILITY = 2204 + RET_MAZE_NO_PLANE = 2205 + RET_MAZE_MAP_NOT_EXIST = 2207 + RET_MAZE_MP_NOT_ENOUGH = 2213 + RET_SPRING_NOT_ENABLE = 2214 + RET_SPRING_TOO_FAR = 2216 + RET_NOT_IN_MAZE = 2218 + RET_MAZE_TIME_OF_DAY_TYPE_ERROR = 2223 + RET_SCENE_TRANSFER_LOCKED_BY_TASK = 2224 + RET_PLOT_NOT_UNLOCK = 2300 + RET_MISSION_NOT_EXIST = 2400 + RET_MISSION_ALREADY_DONE = 2401 + RET_DAILY_TASK_NOT_FINISH = 2402 + RET_DAILY_TASK_REWARD_HAS_TAKEN = 2403 + RET_MISSION_NOT_FINISH = 2404 + RET_MISSION_NOT_DOING = 2405 + RET_MISSION_FINISH_WAY_NOT_MATCH = 2406 + RET_MISSION_SCENE_NOT_MATCH = 2407 + RET_MISSION_CUSTOM_VALUE_NOT_VALID = 2408 + RET_MISSION_SUB_MISSION_NOT_MATCH = 2409 + RET_ADVENTURE_MAP_NOT_EXIST = 2500 + RET_SCENE_ENTITY_NOT_EXIST = 2600 + RET_NOT_IN_SCENE = 2601 + RET_SCENE_MONSTER_NOT_EXIST = 2602 + RET_INTERACT_CONFIG_NOT_EXIST = 2603 + RET_UNSUPPORTED_PROP_STATE = 2604 + RET_SCENE_ENTRY_ID_NOT_MATCH = 2605 + RET_SCENE_ENTITY_MOVE_CHECK_FAILED = 2606 + RET_ASSIST_MONSTER_COUNT_LIMIT = 2607 + RET_SCENE_USE_SKILL_FAIL = 2608 + RET_PROP_IS_HIDDEN = 2609 + RET_LOADING_SUCC_ALREADY = 2610 + RET_SCENE_ENTITY_TYPE_INVALID = 2611 + RET_INTERACT_TYPE_INVALID = 2612 + RET_INTERACT_NOT_IN_REGION = 2613 + RET_INTERACT_SUB_TYPE_INVALID = 2614 + RET_NOT_LEADER_ENTITY = 2615 + RET_MONSTER_IS_NOT_FARM_ELEMENT = 2616 + RET_MONSTER_CONFIG_NOT_EXIST = 2617 + RET_AVATAR_HP_ALREADY_FULL = 2618 + RET_CUR_INTERACT_ENTITY_NOT_MATCH = 2619 + RET_PLANE_TYPE_NOT_ALLOW = 2620 + RET_GROUP_NOT_EXIST = 2621 + RET_GROUP_SAVE_DATA_IN_CD = 2622 + RET_GROUP_SAVE_LENGH_REACH_MAX = 2623 + RET_RECENT_ELEMENT_NOT_EXIST = 2624 + RET_RECENT_ELEMENT_STAGE_NOT_MATCH = 2625 + RET_SCENE_POSITION_VERSION_NOT_MATCH = 2626 + RET_GAMEPLAY_COUNTER_NOT_EXIST = 2627 + RET_GAMEPLAY_COUNTER_NOT_ENOUGH = 2628 + RET_GROUP_STATE_NOT_MATCH = 2629 + RET_SCENE_ENTITY_POS_NOT_MATCH = 2630 + RET_GROUP_STATE_CUSTOM_SAVE_DATA_OFF = 2631 + RET_SCENE_NOT_MATCH = 2632 + RET_PROP_TYPE_INVALID = 2633 + RET_BUY_TIMES_LIMIT = 2700 + RET_BUY_LIMIT_TYPE = 2701 + RET_SHOP_NOT_OPEN = 2702 + RET_GOODS_NOT_OPEN = 2703 + RET_CITY_LEVEL_REWARD_TAKEN = 2704 + RET_CITY_LEVEL_NOT_MEET = 2705 + RET_SINGLE_BUY_LIMIT = 2706 + RET_TUTORIAL_NOT_UNLOCK = 2751 + RET_TUTORIAL_UNLOCK_ALREADY = 2752 + RET_TUTORIAL_FINISH_ALREADY = 2753 + RET_TUTORIAL_PRE_NOT_UNLOCK = 2754 + RET_TUTORIAL_PLAYER_LEVEL_NOT_MATCH = 2755 + RET_TUTORIAL_TUTORIAL_NOT_FOUND = 2756 + RET_CHALLENGE_NOT_EXIST = 2801 + RET_CHALLENGE_NOT_UNLOCK = 2802 + RET_CHALLENGE_ALREADY = 2803 + RET_CHALLENGE_LINEUP_EDIT_FORBIDDEN = 2804 + RET_CHALLENGE_LINEUP_EMPTY = 2805 + RET_CHALLENGE_NOT_DOING = 2806 + RET_CHALLENGE_NOT_FINISH = 2807 + RET_CHALLENGE_TARGET_NOT_FINISH = 2808 + RET_CHALLENGE_TARGET_REWARD_TAKEN = 2809 + RET_CHALLENGE_TIME_NOT_VALID = 2810 + RET_CHALLENGE_STARS_COUNT_NOT_MEET = 2811 + RET_CHALLENGE_STARS_REWARD_TAKEN = 2812 + RET_CHALLENGE_STARS_NOT_EXIST = 2813 + RET_CHALLENGE_CUR_SCENE_NOT_ENTRY_FLOOR = 2814 + RET_CHALLENGE_NO_TEAM_ARCHIVE = 2815 + RET_CHALLENGE_LINEUP_AVATAR_TYPE_INVALID = 2816 + RET_CHALLENGE_LINEUP_RECOMMEND_IN_CD = 2817 + RET_BASIC_TYPE_ALREADY = 2850 + RET_NO_BASIC_TYPE = 2851 + RET_NOT_CHOOSE_BASIC_TYPE = 2852 + RET_NOT_FUNC_CLOSE = 2853 + RET_NOT_CHOOSE_GENDER = 2854 + RET_NOT_REQ_UNLOCK_BASIC_TYPE = 2855 + RET_AVATAR_PATH_LOCKED = 2856 + RET_ROGUE_STATUS_NOT_MATCH = 2901 + RET_ROGUE_SELECT_BUFF_NOT_EXIST = 2902 + RET_ROGUE_COIN_NOT_ENOUGH = 2903 + RET_ROGUE_STAMINA_NOT_ENOUGH = 2904 + RET_ROGUE_APPRAISAL_COUNT_NOT_ENOUGH = 2905 + RET_ROGUE_PROP_ALREADY_USED = 2906 + RET_ROGUE_RECORD_ALREADY_SAVED = 2907 + RET_ROGUE_ROLL_BUFF_MAX_COUNT = 2908 + RET_ROGUE_PICK_AVATAR_INVALID = 2909 + RET_ROGUE_QUEST_EXPIRE = 2910 + RET_ROGUE_QUEST_REWARD_ALREADY = 2911 + RET_ROGUE_REVIVE_COUNT_NOT_ENOUGH = 2912 + RET_ROGUE_AREA_INVALID = 2913 + RET_ROGUE_SCORE_REWARD_POOL_INVALID = 2914 + RET_ROGUE_SCORE_REWARD_ROW_INVALID = 2915 + RET_ROGUE_AEON_LEVEL_NOT_MEET = 2916 + RET_ROGUE_AEON_LEVEL_REWARD_ALREADY_TAKEN = 2917 + RET_ROGUE_AEON_CONFIG_NOT_EXIST = 2918 + RET_ROGUE_TRIAL_AVATAR_INVALID = 2919 + RET_ROGUE_HANDBOOK_REWARD_ALREADY_TAKEN = 2920 + RET_ROGUE_ROOM_TYPE_NOT_MATCH = 2921 + RET_ROGUE_SHOP_GOOD_NOT_FOUND = 2922 + RET_ROGUE_SHOP_GOOD_ALREADY_BOUGHT = 2923 + RET_ROGUE_SHOP_GOOD_ALREADY_OWN = 2924 + RET_ROGUE_SHOP_MIRACLE_NOT_EXIST = 2925 + RET_ROGUE_SHOP_NOT_EXIST = 2926 + RET_ROGUE_SHOP_CANNOT_REFRESH = 2927 + RET_ROGUE_SELECT_BUFF_CERTAIN_MISMATCH = 2928 + RET_ROGUE_ACTION_QUEUE_NOT_EMPTY_BATTLE = 2929 + RET_ROGUE_ACTION_QUEUE_NOT_EMPTY_OTHERS = 2930 + RET_MISSION_EVENT_CONFIG_NOT_EXIST = 2951 + RET_MISSION_EVENT_NOT_CLIENT = 2952 + RET_MISSION_EVENT_FINISHED = 2953 + RET_MISSION_EVENT_DOING = 2954 + RET_HAS_CHALLENGE_MISSION_EVENT = 2955 + RET_NOT_CHALLENGE_MISSION_EVENT = 2956 + RET_GACHA_ID_NOT_EXIST = 3001 + RET_GACHA_NUM_INVALID = 3002 + RET_GACHA_FIRST_GACHA_MUST_ONE = 3003 + RET_GACHA_REQ_DUPLICATED = 3004 + RET_GACHA_NOT_IN_SCHEDULE = 3005 + RET_GACHA_NEWBIE_CLOSE = 3006 + RET_GACHA_TODAY_LIMITED = 3007 + RET_GACHA_NOT_SUPPORT = 3008 + RET_GACHA_CEILING_NOT_ENOUGH = 3009 + RET_GACHA_CEILING_CLOSE = 3010 + RET_GACHA_LOCKED = 3011 + RET_GACHA_DECIDE_ITEM_TYPE_INVALID = 3012 + RET_GACHA_DECIDE_ITEM_ID_INVALID = 3013 + RET_NOT_IN_RAID = 3101 + RET_RAID_DOING = 3102 + RET_NOT_PROP = 3103 + RET_RAID_ID_NOT_MATCH = 3104 + RET_RAID_RESTART_NOT_MATCH = 3105 + RET_RAID_LIMIT = 3106 + RET_RAID_AVATAR_LIST_EMPTY = 3107 + RET_RAID_AVATAR_NOT_EXIST = 3108 + RET_CHALLENGE_RAID_REWARD_ALREADY = 3109 + RET_CHALLENGE_RAID_SCORE_NOT_REACH = 3110 + RET_CHALLENGE_RAID_NOT_OPEN = 3111 + RET_RAID_FINISHED = 3112 + RET_RAID_WORLD_LEVEL_NOT_LOCK = 3113 + RET_RAID_CANNOT_USE_ASSIST = 3114 + RET_RAID_AVATAR_NOT_MATCH = 3115 + RET_RAID_CAN_NOT_SAVE = 3116 + RET_RAID_NO_SAVE = 3117 + RET_ACTIVITY_RAID_NOT_OPEN = 3118 + RET_RAID_AVATAR_CAPTAIN_NOT_EXIST = 3119 + RET_RAID_STORY_LINE_NOT_MATCH = 3120 + RET_TALK_EVENT_ALREADY_TAKEN = 3151 + RET_NPC_ALREADY_MEET = 3152 + RET_NPC_NOT_IN_CONFIG = 3153 + RET_DIALOGUE_GROUP_DISMATCH = 3154 + RET_DIALOGUE_EVENT_INVALID = 3155 + RET_TALK_EVENT_TAKE_PROTO_NOT_MATCH = 3156 + RET_TALK_EVENT_NOT_VALID = 3157 + RET_EXPEDITION_CONFIG_NOT_EXIST = 3201 + RET_EXPEDITION_REWARD_CONFIG_NOT_EXIST = 3202 + RET_EXPEDITION_NOT_UNLOCKED = 3203 + RET_EXPEDITION_ALREADY_ACCEPTED = 3204 + RET_EXPEDITION_REPEATED_AVATAR = 3205 + RET_AVATAR_ALREADY_DISPATCHED = 3206 + RET_EXPEDITION_NOT_ACCEPTED = 3207 + RET_EXPEDITION_NOT_FINISH = 3208 + RET_EXPEDITION_ALREADY_FINISH = 3209 + RET_EXPEDITION_TEAM_COUNT_LIMIT = 3210 + RET_EXPEDITION_AVATAR_NUM_NOT_MATCH = 3211 + RET_EXPEDITION_NOT_OPEN = 3212 + RET_EXPEDITION_FRIEND_AVATAR_NOT_VALID = 3213 + RET_EXPEDITION_NOT_PUBLISHED = 3214 + RET_LOGIN_ACTIVITY_HAS_TAKEN = 3301 + RET_LOGIN_ACTIVITY_DAYS_LACK = 3302 + RET_TRIAL_ACTIVITY_REWARD_ALREADY_TAKE = 3303 + RET_TRIAL_ACTIVITY_STAGE_NOT_FINISH = 3304 + RET_MATERIAL_SUBMIT_ACTIVITY_HAS_TAKEN = 3305 + RET_MATERIAL_SUBMIT_ACTIVITY_MATERIAL_NOT_SUBMITTED = 3306 + RET_MATERIAL_SUBMIT_ACTIVITY_MATERIAL_ALREADY_SUBMITTED = 3307 + RET_FANTASTIC_STORY_ACTIVITY_STORY_ERROR = 3308 + RET_FANTASTIC_STORY_ACTIVITY_STORY_NOT_OPEN = 3309 + RET_FANTASTIC_STORY_ACTIVITY_BATTLE_ERROR = 3310 + RET_FANTASTIC_STORY_ACTIVITY_BATTLE_NOT_OPEN = 3311 + RET_FANTASTIC_STORY_ACTIVITY_BATTLE_AVATAR_ERROR = 3312 + RET_FANTASTIC_STORY_ACTIVITY_BATTLE_BUFF_ERROR = 3313 + RET_FANTASTIC_STORY_ACTIVITY_PRE_BATTLE_SCORE_NOT_ENOUGH = 3314 + RET_TRIAL_ACTIVITY_ALREADY_IN_TRIAL_ACTIVITY = 3315 + RET_COMMON_ACTIVITY_NOT_OPEN = 3316 + RET_BENEFIT_NOT_READY = 3317 + RET_COMMON_ACTIVITY_BUSY = 3318 + RET_AVATAR_DELIVER_REWARD_PHASE_ERROR = 3319 + RET_MESSAGE_CONFIG_NOT_EXIST = 3501 + RET_MESSAGE_SECTION_NOT_TAKE = 3502 + RET_MESSAGE_GROUP_NOT_TAKE = 3503 + RET_MESSAGE_SECTION_ID_NOT_MATCH = 3504 + RET_MESSAGE_SECTION_CAN_NOT_FINISH = 3505 + RET_MESSAGE_ITEM_CAN_NOT_FINISH = 3506 + RET_MESSAGE_ITEM_RAID_CAN_NOT_FINISH = 3507 + RET_FRIEND_ALREADY_IS_FRIEND = 3601 + RET_FRIEND_IS_NOT_FRIEND = 3602 + RET_FRIEND_APPLY_EXPIRE = 3603 + RET_FRIEND_IN_BLACKLIST = 3604 + RET_FRIEND_NOT_IN_BLACKLIST = 3605 + RET_FRIEND_NUMBER_LIMIT = 3606 + RET_FRIEND_BLACKLIST_NUMBER_LIMIT = 3607 + RET_FRIEND_DAILY_APPLY_LIMIT = 3608 + RET_FRIEND_IN_HANDLE_LIMIT = 3609 + RET_FRIEND_APPLY_IN_CD = 3610 + RET_FRIEND_REMARK_NAME_FORMAT_ERROR = 3611 + RET_FRIEND_PLAYER_NOT_FOUND = 3612 + RET_FRIEND_IN_TARGET_BLACKLIST = 3613 + RET_FRIEND_TARGET_NUMBER_LIMIT = 3614 + RET_ASSIST_QUERY_TOO_FAST = 3615 + RET_ASSIST_NOT_EXIST = 3616 + RET_ASSIST_USED_ALREADY = 3617 + RET_FRIEND_REPORT_REASON_FORMAT_ERROR = 3618 + RET_FRIEND_REPORT_SENSITIVE_WORDS = 3619 + RET_ASSIST_USED_TIMES_OVER = 3620 + RET_ASSIST_QUIT_ALREADY = 3621 + RET_ASSIST_AVATAR_IN_LINEUP = 3622 + RET_ASSIST_NO_REWARD = 3623 + RET_FRIEND_SEARCH_NUM_LIMIT = 3624 + RET_FRIEND_SEARCH_IN_CD = 3625 + RET_FRIEND_REMARK_NAME_UTF8_ERROR = 3626 + RET_FRIEND_REPORT_REASON_UTF8_ERROR = 3627 + RET_ASSIST_SET_ALREADY = 3628 + RET_FRIEND_TARGET_FORBID_OTHER_APPLY = 3629 + RET_FRIEND_MARKED_CNT_MAX = 3630 + RET_FRIEND_MARKED_ALREADY = 3631 + RET_FRIEND_NOT_MARKED = 3632 + RET_FRIEND_CHALLENGE_LINEUP_RECOMMEND_IN_CD = 3633 + RET_VIEW_PLAYER_CARD_IN_CD = 3634 + RET_VIEW_PLAYER_BATTLE_RECORD_IN_CD = 3635 + RET_PLAYER_BOARD_HEAD_ICON_NOT_EXIST = 3701 + RET_PLAYER_BOARD_HEAD_ICON_LOCKED = 3702 + RET_PLAYER_BOARD_HEAD_ICON_ALREADY_UNLOCKED = 3703 + RET_PLAYER_BOARD_DISPLAY_AVATAR_NOT_EXIST = 3704 + RET_PLAYER_BOARD_DISPLAY_AVATAR_EXCEED_LIMIT = 3705 + RET_PLAYER_BOARD_DISPLAY_REPEATED_AVATAR = 3706 + RET_PLAYER_BOARD_DISPLAY_AVATAR_SAME_POS = 3707 + RET_PLAYER_BOARD_DISPLAY_AVATAR_LOCKED = 3708 + RET_SIGNATURE_LENGTH_EXCEED_LIMIT = 3709 + RET_SIGNATURE_SENSITIVE_WORDS = 3710 + RET_PLAYER_BOARD_ASSIST_AVATAR_NOT_EXIST = 3712 + RET_PLAYER_BOARD_ASSIST_AVATAR_LOCKED = 3713 + RET_SIGNATURE_UTF8_ERROR = 3714 + RET_PLAYER_BOARD_ASSIST_AVATAR_CNT_ERROR = 3715 + RET_PLAYER_BOARD_PERSONAL_CARD_NOT_EXIST = 3716 + RET_PLAYER_BOARD_PERSONAL_CARD_LOCKED = 3717 + RET_PLAYER_BOARD_PERSONAL_NO_CHANGE = 3718 + RET_BATTLE_PASS_TIER_NOT_VALID = 3801 + RET_BATTLE_PASS_LEVEL_NOT_MEET = 3802 + RET_BATTLE_PASS_REWARD_TAKE_ALREADY = 3803 + RET_BATTLE_PASS_NOT_PREMIUM = 3804 + RET_BATTLE_PASS_NOT_DOING = 3805 + RET_BATTLE_PASS_LEVEL_INVALID = 3806 + RET_BATTLE_PASS_NOT_UNLOCK = 3807 + RET_BATTLE_PASS_NO_REWARD = 3808 + RET_BATTLE_PASS_QUEST_NOT_VALID = 3809 + RET_BATTLE_PASS_NOT_CHOOSE_OPTIONAL = 3810 + RET_BATTLE_PASS_NOT_TAKE_REWARD = 3811 + RET_BATTLE_PASS_OPTIONAL_NOT_VALID = 3812 + RET_BATTLE_PASS_BUY_ALREADY = 3813 + RET_BATTLE_PASS_NEAR_END = 3814 + RET_MUSIC_LOCKED = 3901 + RET_MUSIC_NOT_EXIST = 3902 + RET_MUSIC_UNLOCK_FAILED = 3903 + RET_PUNK_LORD_LACK_SUMMON_TIMES = 4001 + RET_PUNK_LORD_ATTACKING_MONSTER_LIMIT = 4002 + RET_PUNK_LORD_MONSTER_NOT_EXIST = 4003 + RET_PUNK_LORD_MONSTER_ALREADY_SHARED = 4004 + RET_PUNK_LORD_MONSTER_EXPIRED = 4005 + RET_PUNK_LORD_SELF_MONSTER_ATTACK_LIMIT = 4006 + RET_PUNK_LORD_LACK_SUPPORT_TIMES = 4007 + RET_PUNK_LORD_MONSTER_ALREADY_KILLED = 4008 + RET_PUNK_LORD_MONSTER_ATTACKER_LIMIT = 4009 + RET_PUNK_LORD_WORLD_LEVLE_NOT_VALID = 4010 + RET_PUNK_LORD_REWARD_LEVLE_NOT_EXIST = 4011 + RET_PUNK_LORD_POINT_NOT_MEET = 4012 + RET_PUNK_LORD_IN_ATTACKING = 4013 + RET_PUNK_LORD_OPERATION_IN_CD = 4014 + RET_PUNK_LORD_REWARD_ALREADY_TAKEN = 4015 + RET_PUNK_LORD_OVER_BONUS_REWARD_LIMIT = 4016 + RET_PUNK_LORD_NOT_IN_SCHEDULE = 4017 + RET_PUNK_LORD_MONSTER_NOT_ATTACKED = 4018 + RET_PUNK_LORD_MONSTER_NOT_KILLED = 4019 + RET_PUNK_LORD_MONSTER_KILLED_SCORE_ALREADY_TAKE = 4020 + RET_PUNK_LORD_REWARD_LEVLE_ALREADY_TAKE = 4021 + RET_DAILY_ACTIVE_LEVEL_INVALID = 4101 + RET_DAILY_ACTIVE_LEVEL_REWARD_ALREADY_TAKEN = 4102 + RET_DAILY_ACTIVE_LEVEL_AP_NOT_ENOUGH = 4103 + RET_DAILY_MEET_PAM = 4201 + RET_REPLAY_ID_NOT_MATCH = 4251 + RET_REPLAY_REQ_NOT_VALID = 4252 + RET_FIGHT_ACTIVITY_DIFFICULTY_LEVEL_NOT_PASSED = 4301 + RET_FIGHT_ACTIVITY_DIFFICULTY_LEVEL_REWARD_ALREADY_TAKE = 4302 + RET_FIGHT_ACTIVITY_STAGE_NOT_OPEN = 4303 + RET_FIGHT_ACTIVITY_LEVEL_NOT_UNLOCK = 4304 + RET_TRAIN_VISITOR_VISITOR_NOT_EXIST = 4351 + RET_TRAIN_VISITOR_BEHAVIOR_NOT_EXIST = 4352 + RET_TRAIN_VISITOR_BEHAVIOR_FINISHED = 4353 + RET_TRAIN_VISITOR_ALL_BEHAVIOR_REWARD_TAKEN = 4354 + RET_TRAIN_VISITOR_GET_ON_MISSION_NOT_FINISH = 4355 + RET_TRAIN_VISITOR_NOT_GET_OFF_OR_BE_TRAIN_MEMBER = 4356 + RET_TEXT_JOIN_UNKNOW_IS_OVERRIDE = 4401 + RET_TEXT_JOIN_ID_NOT_EXIST = 4402 + RET_TEXT_JOIN_CAN_NOT_OVERRIDE = 4403 + RET_TEXT_JOIN_ITEM_ID_ERROR = 4404 + RET_TEXT_JOIN_SENSITIVE_CHECK_ERROR = 4405 + RET_TEXT_JOIN_MUST_OVERRIDE = 4406 + RET_TEXT_JOIN_TEXT_EMPTY = 4407 + RET_TEXT_JOIN_TEXT_FORMAT_ERROR = 4408 + RET_TEXT_JOIN_TEXT_UTF8_ERROR = 4409 + RET_TEXT_JOIN_BATCH_REQ_ID_REPEAT = 4410 + RET_TEXT_JOIN_TYPE_NOT_SUPPORT_BATCH_REQ = 4411 + RET_TEXT_JOIN_AVATAR_ID_NOT_EXIST = 4412 + RET_TEXT_JOIN_UNKNOW_TYPE = 4413 + RET_PAM_MISSION_MISSION_ID_ERROR = 4451 + RET_PAM_MISSION_MISSION_EXPIRE = 4452 + RET_CHAT_TYPE_NOT_EXIST = 4501 + RET_MSG_TYPE_NOT_EXIST = 4502 + RET_CHAT_NO_TARGET_UID = 4503 + RET_CHAT_MSG_EMPTY = 4504 + RET_CHAT_MSG_EXCEED_LIMIT = 4505 + RET_CHAT_MSG_SENSITIVE_CHECK_ERROR = 4506 + RET_CHAT_MSG_UTF8_ERROR = 4507 + RET_CHAT_FORBID_SWITCH_OPEN = 4508 + RET_CHAT_FORBID = 4509 + RET_CHAT_MSG_INCLUDE_SPECIAL_STR = 4510 + RET_CHAT_MSG_EMOJI_NOT_EXIST = 4511 + RET_CHAT_MSG_EMOJI_GENDER_NOT_MATCH = 4512 + RET_CHAT_MSG_EMOJI_NOT_MARKED = 4513 + RET_CHAT_MSG_EMOJI_ALREADY_MARKED = 4514 + RET_CHAT_MSG_EMOJI_MARKED_MAX_LIMIT = 4515 + RET_BOXING_CLUB_CHALLENGE_NOT_OPEN = 4601 + RET_MUSEUM_NOT_OPEN = 4651 + RET_MUSEUM_TURN_CNT_NOT_MATCH = 4652 + RET_MUSEUM_PHASE_NOT_REACH = 4653 + RET_MUSEUM_UNKNOW_STUFF = 4654 + RET_MUSEUM_UNKNOW_AREA = 4655 + RET_MUSEUM_UNKNOW_POS = 4656 + RET_MUSEUM_STUFF_ALREADY_IN_AREA = 4657 + RET_MUSEUM_STUFF_NOT_IN_AREA = 4658 + RET_MUSEUM_GET_NPC_REPEAT = 4659 + RET_MUSEUM_GET_NPC_UNLOCK = 4660 + RET_MUSEUM_GET_NPC_NOT_ENOUGH = 4661 + RET_MUSEUM_CHANGE_STUFF_AREA_ERROR = 4662 + RET_MUSEUM_NOT_INIT = 4663 + RET_MUSEUM_EVENT_ERROR = 4664 + RET_MUSEUM_UNKNOW_CHOOSE_EVENT_ID = 4665 + RET_MUSEUM_EVENT_ORDER_NOT_MATCH = 4666 + RET_MUSEUM_EVENT_PHASE_NOT_UNLOCK = 4667 + RET_MUSEUM_EVENT_MISSION_NOT_FOUND = 4668 + RET_MUSEUM_AREA_LEVEL_UP_ALREADY = 4669 + RET_MUSEUM_STUFF_ALREADY_USED = 4670 + RET_MUSEUM_EVENT_ROUND_NOT_UNLOCK = 4671 + RET_MUSEUM_STUFF_IN_AREA = 4672 + RET_MUSEUM_STUFF_DISPATCH = 4673 + RET_MUSEUM_IS_END = 4674 + RET_MUSEUM_STUFF_LEAVING = 4675 + RET_MUSEUM_EVENT_MISSION_NOT_FINISH = 4678 + RET_MUSEUM_COLLECT_REWARD_NOT_EXIST = 4679 + RET_MUSEUM_COLLECT_REWARD_ALREADY_TAKEN = 4680 + RET_MUSEUM_ACCEPT_MISSION_MAX_LIMIT = 4681 + RET_ROGUE_CHALLENGE_NOT_OPEN = 4701 + RET_ROGUE_CHALLENGE_ASSIS_REFRESH_LIMIT = 4702 + RET_ALLEY_NOT_INIT = 4721 + RET_ALLEY_NOT_OPEN = 4722 + RET_ALLEY_MAP_NOT_EXIST = 4724 + RET_ALLEY_EMPTY_POS_LIST = 4725 + RET_ALLEY_LINE_POS_INVALID = 4726 + RET_ALLEY_SHOP_NOT_UNLOCK = 4727 + RET_ALLEY_DEPOT_FULL = 4728 + RET_ALLEY_SHOP_NOT_INCLUDE = 4729 + RET_ALLEY_EVENT_NOT_UNLOCK = 4730 + RET_ALLEY_EVENT_NOT_REFRESH = 4731 + RET_ALLEY_EVENT_STATE_DOING = 4732 + RET_ALLEY_EVENT_STATE_FINISH = 4733 + RET_ALLEY_EVENT_ERROR = 4734 + RET_ALLEY_REWARD_LEVEL_ERROR = 4735 + RET_ALLEY_REWARD_PRESTIGE_NOT_ENOUGH = 4736 + RET_ALLEY_SHIP_EMPTY = 4737 + RET_ALLEY_SHIP_ID_DISMATCH = 4738 + RET_ALLEY_SHIP_NOT_EXIST = 4739 + RET_ALLEY_SHIP_NOT_UNLOCK = 4740 + RET_ALLEY_GOODS_NOT_EXIST = 4741 + RET_ALLEY_GOODS_NOT_UNLOCK = 4742 + RET_ALLEY_PROFIT_NOT_POSITIVE = 4743 + RET_ALLEY_SPECIAL_ORDER_DISMATCH = 4744 + RET_ALLEY_ORDER_GOODS_OVER_LIMIT = 4745 + RET_ALLEY_SPECIAL_ORDER_CONDITION_NOT_MEET = 4746 + RET_ALLEY_DEPOT_SIZE_OVER_LIMIT = 4747 + RET_ALLEY_GOODS_NOT_ENOUGH = 4748 + RET_ALLEY_ORDER_INDEX_INVALID = 4749 + RET_ALLEY_REWARD_ALREADY_TAKE = 4750 + RET_ALLEY_REWARD_NOT_EXIST = 4751 + RET_ALLEY_MAIN_MISSION_NOT_DOING = 4752 + RET_ALLEY_CRITICAL_EVENT_NOT_FINISH = 4753 + RET_ALLEY_SHOP_GOODS_NOT_VALID = 4754 + RET_ALLEY_SLASH_NOT_OPEN = 4755 + RET_ALLEY_PLACING_ANCHOR_INVALID = 4756 + RET_ALLEY_PLACING_GOODS_INDEX_INVALID = 4757 + RET_ALLEY_SAVE_MAP_TOO_QUICK = 4758 + RET_ALLEY_MAP_NOT_LINK = 4759 + RET_ALLEY_FUNDS_NOT_LOWER_BASE = 4760 + RET_ALLEY_EVENT_NOT_FINISH = 4761 + RET_ALLEY_NORMAL_ORDER_NOT_MEET = 4762 + RET_PLAYER_RETURN_NOT_OPEN = 4801 + RET_PLAYER_RETURN_IS_SIGNED = 4802 + RET_PLAYER_RETURN_POINT_NOT_ENOUGH = 4803 + RET_PLAYER_RETURN_CONDITION_INVALID = 4804 + RET_PLAYER_RETURN_HAS_SIGNED = 4805 + RET_PLAYER_RETURN_REWARD_TAKEN = 4806 + RET_PLAYER_RETURN_RELIC_TAKEN = 4807 + RET_AETHER_DIVIDE_NO_LINEUP = 4851 + RET_AETHER_DIVIDE_LINEUP_INVALID = 4852 + RET_CHAT_BUBBLE_ID_ERROR = 4901 + RET_CHAT_BUBBLE_ID_NOT_UNLOCK = 4902 + RET_PHONE_THEME_ID_ERROR = 4903 + RET_PHONE_THEME_ID_NOT_UNLOCK = 4904 + RET_CHAT_BUBBLE_SELECT_IS_CURRENT = 4905 + RET_PHONE_THEME_SELECT_IS_CURRENT = 4906 + RET_PHONE_CASE_ID_ERROR = 4907 + RET_PHONE_CASE_ID_NOT_UNLOCK = 4908 + RET_PHONE_CASE_SELECT_IS_CURRENT = 4909 + RET_CHESS_ROGUE_CONFIG_NOT_FOUND = 4951 + RET_CHESS_ROGUE_CONFIG_INVALID = 4952 + RET_CHESS_ROGUE_NO_VALID_ROOM = 4963 + RET_CHESS_ROGUE_NO_CELL_INFO = 4964 + RET_CHESS_ROGUE_CELL_NOT_FINISH = 4965 + RET_CHESS_ROGUE_CELL_IS_LOCKED = 4966 + RET_CHESS_ROGUE_SCHEDULE_NOT_MATCH = 4967 + RET_CHESS_ROGUE_STATUS_FAIL = 4968 + RET_CHESS_ROGUE_AREA_NOT_EXIST = 4969 + RET_CHESS_ROGUE_LINEUP_FAIL = 4970 + RET_CHESS_ROGUE_AEON_FAIL = 4980 + RET_CHESS_ROGUE_ENTER_CELL_FAIL = 4981 + RET_CHESS_ROGUE_ROLL_DICE_FAIL = 4982 + RET_CHESS_ROGUE_DICE_STATUS_FAIL = 4983 + RET_CHESS_ROGUE_DICE_CNT_NOT_FULL = 4984 + RET_CHESS_ROGUE_UNLOCK = 4985 + RET_CHESS_ROGUE_PICK_AVATAR_FAIL = 4986 + RET_CHESS_ROGUE_AVATAR_INVALID = 4987 + RET_CHESS_ROGUE_CELL_CAN_NOT_SELECT = 4988 + RET_CHESS_ROGUE_DICE_CONFIRMED = 4989 + RET_CHESS_ROGUE_NOUS_DICE_NOT_MATCH = 4990 + RET_CHESS_ROGUE_NOUS_DICE_RARITY_FAIL = 4991 + RET_CHESS_ROGUE_NOUS_DICE_SURFACE_DUPLICATE = 4992 + RET_CHESS_ROGUE_NOT_IN_ROGUE = 4993 + RET_CHESS_ROGUE_NOUS_DICE_BRANCH_LIMIT = 4994 + RET_HELIOBUS_NOT_OPEN = 5101 + RET_HELIOBUS_SNS_POST_NOT_UNLOCK = 5102 + RET_HELIOBUS_SNS_ALREADY_READ = 5103 + RET_HELIOBUS_SNS_ALREADY_LIKED = 5104 + RET_HELIOBUS_SNS_ALREADY_COMMENTED = 5105 + RET_HELIOBUS_SNS_IN_MISSION = 5106 + RET_HELIOBUS_SNS_ALREADY_POSTED = 5107 + RET_HELIOBUS_SNS_NOT_DOING_MISSION = 5108 + RET_HELIOBUS_REWARD_LEVEL_MAX = 5109 + RET_HELIOBUS_INCOME_NOT_ENOUGH = 5110 + RET_HELIOBUS_SNS_COMMENT_NOT_UNLOCK = 5111 + RET_HELIOBUS_CHALLENGE_NOT_UNLOCK = 5112 + RET_HELIOBUS_CHALLENGE_ID_ERROR = 5113 + RET_HELIOBUS_SKILL_NOT_UNLOCK = 5114 + RET_HELIOBUS_ACCEPT_POST_MISSION_FAIL = 5115 + RET_HELIOBUS_SKILL_NOT_SELECTED = 5116 + RET_HELIOBUS_PLANE_TYPE_INVALID = 5117 + RET_REDDOT_PARAM_INVALID = 5151 + RET_REDDOT_ACTIVITY_NOT_OPEN = 5152 + RET_ROGUE_ENDLESS_ACTIVITY_CONFIG_ERROR = 5201 + RET_ROGUE_ENDLESS_ACTIVITY_NOT_OPEN = 5202 + RET_ROGUE_ENDLESS_ACTIVITY_OVER_BONUS_REWARD_LIMIT = 5203 + RET_ROGUE_ENDLESS_ACTIVITY_SCORE_NOT_MEET = 5204 + RET_ROGUE_ENDLESS_ACTIVITY_REWARD_LEVLE_ALREADY_TAKE = 5205 + RET_HEART_DIAL_SCRIPT_NOT_FOUND = 5251 + RET_HEART_DIAL_SCRIPT_EMOTION_THE_SAME = 5252 + RET_HEART_DIAL_SCRIPT_STEP_NOT_NORMAL = 5253 + RET_HEART_DIAL_SCRIPT_CONDITION_NOT_MATCH = 5254 + RET_HEART_DIAL_SCRIPT_SUBMIT_ITEM_NUM_NOT_MATCH = 5255 + RET_HEART_DIAL_SCRIPT_SUBMIT_ITEM_ID_NOT_MATCH = 5256 + RET_HEART_DIAL_DIALOGUE_NOT_FOUND = 5257 + RET_HEART_DIAL_DIALOGUE_ALREADY_PERFORMED = 5258 + RET_HEART_DIAL_NPC_NOT_FOUND = 5259 + RET_HEART_DIAL_TRACE_CONFIG_NOT_FOUND = 5260 + RET_HEART_DIAL_FLOOR_TRACE_EXIST = 5261 + RET_HEART_DIAL_TRACE_FLOOR_NOT_MATCH = 5262 + RET_TRAVEL_BROCHURE_CONFIG_ERROR = 5301 + RET_TRAVEL_BROCHURE_PARAM_INVALID = 5302 + RET_TRAVEL_BROCHURE_LOCKED = 5303 + RET_TRAVEL_BROCHURE_CANNOT_OPERATE = 5304 + RET_TRAVEL_BROCHURE_WORLD_ID_NOT_MATCH = 5305 + RET_TRAVEL_BROCHURE_HAS_NO_WORLD_BOOK = 5306 + RET_TRAVEL_BROCHURE_PAGE_FULL = 5307 + RET_MAP_ROTATION_NOT_IN_REGION = 5351 + RET_MAP_ROTATION_ROTATER_ALREADY_DEPLOYED = 5352 + RET_MAP_ROTATION_ENERGY_NOT_ENOUGH = 5353 + RET_MAP_ROTATION_ENTITY_NOT_ON_CUR_POSE = 5354 + RET_MAP_ROTATION_ROTATER_NOT_DEPLOYED = 5355 + RET_MAP_ROTATION_POSE_ROTATER_MISMATCH = 5356 + RET_MAP_ROTATION_ROTATER_NOT_REMOVABLE = 5357 + RET_MAP_ROTATION_ROTATER_DISPOSABLE = 5358 + RET_SPACE_ZOO_ACTIVITY_CAT_NOT_FOUND = 5401 + RET_SPACE_ZOO_ACTIVITY_CAT_PARAM_INVALID = 5402 + RET_SPACE_ZOO_ACTIVITY_CAT_ITEM_NOT_ENOUGH = 5403 + RET_SPACE_ZOO_ACTIVITY_CAT_BAG_FULL = 5404 + RET_SPACE_ZOO_ACTIVITY_CAT_NOT_TO_MUTATE = 5405 + RET_SPACE_ZOO_ACTIVITY_CAT_STATE_ERROR = 5406 + RET_SPACE_ZOO_ACTIVITY_CAT_CATTERY_LOCKED = 5407 + RET_SPACE_ZOO_ACTIVITY_CAT_OUT_NOW = 5408 + RET_SPACE_ZOO_ACTIVITY_CAT_CONFIG_NOT_FOUND = 5409 + RET_SPACE_ZOO_ACTIVITY_CAT_FEATURE_NOT_FOUND = 5410 + RET_SPACE_ZOO_ACTIVITY_CAT_ADD_CAT_ERROR = 5411 + RET_SPACE_ZOO_ACTIVITY_CAT_MONEY_NOT_ENOUGH = 5412 + RET_SPACE_ZOO_ACTIVITY_CAT_COND_NOT_MATCH = 5413 + RET_STRONG_CHALLENGE_ACTIVITY_STAGE_CFG_MISS = 5501 + RET_STRONG_CHALLENGE_ACTIVITY_STAGE_NOT_OPEN = 5502 + RET_STRONG_CHALLENGE_ACTIVITY_BUFF_ERROR = 5503 + RET_ROLL_SHOP_NOT_FOUND = 5551 + RET_ROLL_SHOP_GROUP_EMPTY = 5552 + RET_ROLL_SHOP_EMPTY = 5553 + RET_ROLL_SHOP_GACHA_REQ_DUPLICATED = 5554 + RET_ROLL_SHOP_RANDOM_ERROR = 5555 + RET_ROLL_SHOP_GROUP_TYPE_NOT_FOUND = 5556 + RET_ROLL_SHOP_HAS_STORED_REWARD_ALREADY = 5557 + RET_ROLL_SHOP_NO_STORED_REWARD = 5558 + RET_ROLL_SHOP_NOT_IN_VALID_SCENE = 5559 + RET_ROLL_SHOP_INVALID_ROLL_SHOP_TYPE = 5560 + RET_ACTIVITY_RAID_COLLECTION_PREV_NOT_FINISH = 5601 + RET_ACTIVITY_RAID_COLLECTION_GROUP_ENTER_NEXT_UNAVAILABLE = 5602 + RET_ACTIVITY_RAID_COLLECTION_IS_LAST = 5603 + RET_ACTIVITY_RAID_COLLECTION_IS_NOT_NEXT = 5604 + RET_OFFERING_NOT_UNLOCK = 5651 + RET_OFFERING_LEVEL_NOT_UNLOCK = 5652 + RET_OFFERING_REACH_MAX_LEVEL = 5653 + RET_OFFERING_ITEM_NOT_ENOUGH = 5654 + RET_OFFERING_LONGTAIL_NOT_OPEN = 5655 + RET_OFFERING_REWARD_CONDITION = 5656 + RET_DRINK_MAKER_CHAT_INVALID = 5701 + RET_DRINK_MAKER_PARAM_INVALID = 5702 + RET_DRINK_MAKER_PARAM_NOT_UNLOCK = 5703 + RET_DRINK_MAKER_CONFIG_NOT_FOUND = 5704 + RET_DRINK_MAKER_NOT_LAST_CHAT = 5705 + RET_DRINK_MAKER_DAY_AND_FREE_PHASE_NOT_OPEN = 5706 + RET_MONOPOLY_NOT_OPEN = 5751 + RET_MONOPOLY_CONFIG_ERROR = 5752 + RET_MONOPOLY_DICE_NOT_ENOUGH = 5753 + RET_MONOPOLY_CUR_CELL_NOT_FINISH = 5754 + RET_MONOPOLY_COIN_NOT_ENOUGH = 5755 + RET_MONOPOLY_CELL_WAIT_PENDING = 5756 + RET_MONOPOLY_CELL_STATE_ERROR = 5757 + RET_MONOPOLY_CELL_CONTENT_ERROR = 5758 + RET_MONOPOLY_ITEM_NOT_ENOUGH = 5759 + RET_MONOPOLY_CELL_CONTENT_CANNOT_GIVEUP = 5760 + RET_MONOPOLY_ASSET_LEVEL_INVALID = 5761 + RET_MONOPOLY_TURN_NOT_FINISH = 5762 + RET_MONOPOLY_GUIDE_NOT_FINISH = 5763 + RET_MONOPOLY_RAFFLE_REWARD_REISSUED = 5764 + RET_MONOPOLY_NO_GAME_ACTIVE = 5771 + RET_MONOPOLY_GAME_RATIO_NOT_INCREASABLE = 5772 + RET_MONOPOLY_GAME_RATIO_MAX = 5773 + RET_MONOPOLY_GAME_TARGET_RATIO_INVALID = 5774 + RET_MONOPOLY_GAME_BINGO_FLIP_POS_INVALID = 5775 + RET_MONOPOLY_GAME_GUESS_ALREADY_CHOOSE = 5776 + RET_MONOPOLY_GAME_GUESS_CHOOSE_INVALID = 5777 + RET_MONOPOLY_GAME_GUESS_INFORMATION_ALREADY_BOUGHT = 5778 + RET_MONOPOLY_GAME_RAISE_RATIO_NOT_UNLOCK = 5779 + RET_MONOPOLY_FRIEND_NOT_SYNCED = 5785 + RET_MONOPOLY_GET_FRIEND_RANKING_LIST_IN_CD = 5786 + RET_MONOPOLY_LIKE_TARGET_NOT_FRIEND = 5787 + RET_MONOPOLY_DAILY_ALREADY_LIKED = 5788 + RET_MONOPOLY_SOCIAL_EVENT_STATUS_NOT_MATCH = 5789 + RET_MONOPOLY_SOCIAL_EVENT_SERVER_CACHE_NOT_EXIST = 5790 + RET_MONOPOLY_ACTIVITY_ID_NOT_MATCH = 5791 + RET_MONOPOLY_RAFFLE_POOL_NOT_EXIST = 5792 + RET_MONOPOLY_RAFFLE_POOL_TIME_NOT_MATCH = 5793 + RET_MONOPOLY_RAFFLE_POOL_PHASE_NOT_MEET = 5794 + RET_MONOPOLY_RAFFLE_POOL_SHOW_TIME_NOT_MEET = 5795 + RET_MONOPOLY_RAFFLE_TICKET_NOT_FOUND = 5796 + RET_MONOPOLY_RAFFLE_TICKET_TIME_NOT_MEET = 5797 + RET_MONOPOLY_RAFFLE_TICKET_REWARD_ALREADY_TAKEN = 5798 + RET_MONOPOLY_RAFFLE_POOL_NOT_IN_RAFFLE_TIME = 5799 + RET_MONOPOLY_MBTI_REPORT_REWARD_ALREADY_TAKEN = 5800 + RET_EVOLVE_BUILD_LEVEL_GAMING = 5801 + RET_EVEOLVE_BUILD_LEVEL_BAN_RANDOM = 5802 + RET_EVOLVE_BUILD_FIRST_REWARD_ALREADY_TAKEN = 5803 + RET_EVOLVE_BUILD_LEVEL_UNFINISH = 5804 + RET_EVOLVE_BUILD_SHOP_ABILITY_MAX_LEVEL = 5805 + RET_EVOLVE_BUILD_SHOP_ABILITY_MIN_LEVEL = 5806 + RET_EVOLVE_BUILD_SHOP_ABILITY_NOT_GET = 5807 + RET_EVOLVE_BUILD_LEVEL_LOCK = 5808 + RET_EVOLVE_BUILD_EXP_NOT_ENOUGH = 5809 + RET_EVOLVE_BUILD_SHOP_ABILITY_LEVEL_ERROR = 5810 + RET_EVOLVE_BUILD_ACTIVITY_NOT_OPEN = 5811 + RET_EVOLVE_BUILD_SHOP_ABILITY_EMPTY = 5812 + RET_EVOLVE_BUILD_LEVEL_NOT_START = 5813 + RET_EVOLVE_BUILD_SHOP_LOCK = 5814 + RET_EVOLVE_BUILD_REWARD_LOCK = 5815 + RET_EVOLVE_BUILD_REWARD_LEVEL_MAX = 5816 + RET_EVOLVE_BUILD_REWARD_ALREADY_ALL_TAKEN = 5717 + RET_EVOLVE_BUILD_SEASON_ERROR = 5718 + RET_EVOLVE_BUILD_TEACH_SKIP_QUEST_NOT_FINISH = 5719 + RET_CLOCK_PARK_CONFIG_ERROR = 5851 + RET_CLOCK_PARK_EFFECT_ERROR = 5852 + RET_CLOCK_PARK_SCRIPT_ALREADY_UNLOCK = 5853 + RET_CLOCK_PARK_SCRIPT_UNLOCK_CONDITION_NOT_MEET = 5854 + RET_CLOCK_PARK_TALENT_ALREADY_UNLOCK = 5855 + RET_CLOCK_PARK_SCRIPT_LOCKED = 5856 + RET_CLOCK_PARK_HAS_ONGOING_SCRIPT = 5857 + RET_CLOCK_PARK_NO_ONGOING_SCRIPT = 5858 + RET_CLOCK_PARK_DICE_PLACEMENT_ERROR = 5859 + RET_CLOCK_PARK_MISMATCH_STATUS = 5860 + RET_CLOCK_PARK_NO_BUFF = 5861 + RET_CLOCK_PARK_SLOT_MACHINE_GACHA_REQ_DUPLICATED = 5862 + RET_CLOCK_PARK_SLOT_MACHINE_COST_NOT_ENOUGH = 5863 + RET_CLOCK_PARK_SLOT_MACHINE_GACHA_CNT_EXCEED_LIMIT = 5864 + RET_CLOCK_PARK_NOT_OPEN = 5865 + RET_TOURN_ROGUE_STATUS_MISMATCH = 5901 + RET_MAGIC_ROGUE_STATUS_MISMATCH = 5902 + RET_AUTO_MOUNT_MAGIC_UNIT_NO_MATCHED_MAGIC_SCEPTER = 5903 + RET_MAGIC_UNIT_WORKBENCH_REFORGE_GEN_FAIL = 5904 + RET_MATCH_ALREADY_IN_MATCH = 6201 + RET_MATCH_NOT_IN_MATCH = 6202 + RET_MATCH_PLAY_NOT_OPEN = 6203 + RET_CROSS_STATE_ERROR = 6204 + RET_MATCH_VERSION_NOT_EQUAL = 6205 + RET_MATCH_PLAYER_NOT_IN_LOBBY_ROOM = 6206 + RET_LOBBY_STATE_NOT_MATCH = 6207 + RET_LOBBY_ROOM_NOT_EXIST = 6208 + RET_LOBBY_ROOM_PALYER_FULL = 6209 + RET_LOBBY_ROOM_PALYER_NOT_READY = 6210 + RET_LOBBY_ROOM_PALYER_FIGHTING = 6211 + RET_FIGHT_ROOM_NOT_EXIST = 6250 + RET_FIGHT_MATCH3_PLAYER_STATE_ERR = 6251 + RET_FIGHT_MATCH3_ROOM_STATE_ERR = 6252 + RET_CROSS_STATE_TIME_OUT = 6253 + RET_LOBBY_START_FIGHT_DISABLE = 6254 + RET_LOBBY_START_FIGHT_PLAYER_LACK = 6255 + RET_MATCH_CLIENT_DATA_VERSION_LOW = 6256 + RET_LOBBY_START_MATCH_DISABLE = 6257 + RET_LOBBY_INTERACT_IN_CD = 6258 + RET_LOBBY_OWNER_STATE_ERR = 6259 + RET_LOBBY_OP_TOO_FAST = 6260 + RET_SWORD_TRAINING_NO_ACTIVE_GAME = 6301 + RET_SWORD_TRAINING_NO_PENDING_ACTION_MATCH = 6302 + RET_SWORD_TRAINING_PARTNER_ABILITY_INVALID = 6303 + RET_SWORD_TRAINING_SKILL_ALREADY_LEARNED = 6304 + RET_SWORD_TRAINING_CONDITION_NOT_MEET = 6305 + RET_SWORD_TRAINING_PARENT_SKILL_NOT_LEARNED = 6306 + RET_SWORD_TRAINING_SKILL_TYPE_NOT_UNLOCK = 6307 + RET_SWORD_TRAINING_GAME_ALREADY_EXIST = 6308 + RET_SWORD_TRAINING_ENDING_HINT_NOT_MATCH = 6309 + RET_SWORD_TRAINING_STORYLINE_CONFIG_NOT_FOUND = 6310 + RET_SWORD_TRAINING_STORY_CONFIG_NOT_FOUND = 6311 + RET_SWORD_TRAINING_UNLOCK_NOT_FINISH = 6312 + RET_SWORD_TRAINING_OPTION_MISMATCH = 6313 + RET_SWORD_TRAINING_RESTORE_WITHOUT_EXAM_FAILED = 6314 + RET_SWORD_TRAINING_NO_RESTORE_GAME_AVAILABLE = 6315 + RET_SWORD_TRAINING_ENDING_STORY_NOT_MATCH = 6316 + RET_SWORD_TRAINING_ENDING_NOT_FINISH = 6317 + RET_SWORD_TRAINING_ENDING_REWARD_TAKEN = 6318 + RET_SWORD_TRAINING_COMBAT_RANK_NOT_CHANGE = 6319 + RET_SWORD_TRAINING_DIRECT_BATTLE_DISABLE = 6320 + RET_FIGHT_FEST_PHASE_NOT_MATCH = 6351 + RET_FIGHT_FEST_SCORE_RACE_ALREADY_FINISH = 6352 + RET_FIGHT_FEST_CHALLENGE_LOCKED = 6353 + RET_FIGHT_FEST_COACH_SKILL_LOCKED = 6354 + RET_FIGHT_FEST_COACH_SKILL_EQUIP_TYPE_EXISTED = 6355 + RET_FIGHT_FEST_SCORE_RACE_MISSION_DOIND = 6356 + RET_FIGHT_FEST_COACH_SKILL_NO_EQUIP = 6357 + RET_PET_NOT_EXIST = 6401 + RET_PET_ALREADY_SUMMONED = 6402 + RET_PET_NOT_SUMMONED = 6403 + RET_MUSIC_RHYTHM_LEVEL_TIME_TOO_SHORT = 6451 + RET_MUSIC_RHYTHM_NOT_IN_LEVEL = 6452 + RET_MUSIC_RHYTHM_PRE_DIFFICULTY_NOT_PASS = 6453 + RET_MUSIC_RHYTHM_SONG_LIMITED = 6454 + RET_MUSIC_RHYTHM_SONG_LOCKED = 6455 + RET_MUSIC_RHYTHM_TRACK_LOCKED = 6456 + RET_MUSIC_RHYTHM_LEVEL_NOT_UNLOCK = 6457 + RET_MUSIC_RHYTHM_SONG_SFX_LOCKED = 6458 + RET_TRAIN_PARTY_COIN_NOT_ENOUGH = 6501 + RET_TRAIN_PARTY_DIY_TAG_NOT_MATCH = 6502 + RET_TRAIN_PARTY_USE_CARD_MOBILITY_NOT_ENOUGH = 6503 + RET_TRAIN_PARTY_AREA_UNLOCK_COIN_NOT_ENOUGH = 6504 + RET_TAROT_BOOK_ENERGY_NOT_ENOUGH = 6601 + RET_TAROT_BOOK_PACK_NOT_AVAILABLE = 6602 + RET_TAROT_BOOK_STORY_ALREADY_UNLOCK = 6603 + RET_TAROT_BOOK_CARD_NOT_ENOUGH = 6604 + RET_TAROT_BOOK_CLUE_NOT_ENOUGH = 6605 + RET_TAROT_BOOK_UNLOCK_STORY_CARD_NOT_SAME = 6606 + RET_TAROT_BOOK_STORY_NOT_UNLOCK = 6607 + RET_TAROT_BOOK_STORY_ALREADY_FINISH = 6608 + RET_TAROT_BOOK_INTERACTION_ALREADY_FINISH = 6609 + RET_CHIMERA_CHIMERA_NOT_UNLOCK = 6621 + RET_CHIMERA_CHIMERA_DUPLICATED = 6622 + RET_CHIMERA_CHIMERA_TYPE_ERROR = 6623 + RET_CHIMERA_WORK_MISMATCH_ROUND = 6624 + RET_CHIMERA_WORK_ROUND_OPTION_NOT_MEET = 6625 + RET_CHIMERA_ENDLESS_NOT_UNLOCK = 6626 + RET_CHIMERA_IN_ENDLESS = 6627 + RET_CHIMERA_NOT_IN_ENDLESS = 6628 + RET_CHIMERA_CHIMERA_FALL_IN_ENDLESS = 6629 + RET_PLANET_FES_AVATAR_NOT_EXIST = 6641 + RET_PLANET_FES_LAND_NOT_EXIST = 6642 + RET_PLANET_FES_ITEM_NOT_ENOUGH = 6643 + RET_PLANET_FES_LAND_ALREADY_UNLOCK = 6644 + RET_PLANET_FES_WORK_AVATAR_REPEAT = 6645 + RET_PLANET_FES_WORK_AVATAR_TYPE_NOT_MATCH = 6646 + RET_PLANET_FES_ACTIVITY_NOT_OPEN = 6647 + RET_PLANET_FES_SKILLTREE_PHASE_NOT_UNLOCK = 6648 + RET_PLANET_FES_SKILL_NOT_UNLOCK = 6649 + RET_PLANET_FES_CONFIG_ERROR = 6650 + RET_PLANET_FES_NOT_IN_BUSINESS_DAY = 6651 + RET_PLANET_FES_EVENT_LOCKED = 6652 + RET_PLANET_FES_EVENT_FINISHED = 6653 + RET_PLANET_FES_EVENT_IN_CD = 6654 + RET_PLANET_FES_EVENT_ALREADY_IN_STATE = 6655 + RET_PLANET_FES_EVENT_NO_WORK_AVATAR = 6656 + RET_PLANET_FES_EVENT_PROCESSING_CANNOT_DISAPPEAR = 6657 + RET_PLANET_FES_EVENT_OPTION_PHASE_WRONG = 6658 + RET_PLANET_FES_FUNCTION_NOT_UNLOCK = 6659 + RET_PLANET_FES_REWARD_ALREADY_TAKEN = 6660 + RET_PLANET_FES_EVENT_GAME_NOT_ACTIVE = 6661 + RET_PLANET_FES_REGION_PROGRESS_NOT_ENOUGH = 6662 + RET_PLANET_FES_FRIEND_ITEM_NOT_ENOUGH = 6663 + RET_PLANET_FES_PIECE_PERMISSION_BAN = 6664 + RET_PLANET_FES_PIECE_OFFER_NOT_EXIST = 6665 + RET_PLANET_FES_PIECE_APPLY_IN_STACK_TOO_MUCH = 6666 + RET_PLANET_FES_PIECE_APPLY_NOT_EXIST = 6667 + RET_PLANET_FES_GET_FRIEND_RANKING_LIST_IN_CD = 6668 + RET_PLANET_FES_GIVE_PIECE_OWNED_BY_TARGET = 6669 + RET_PLANET_FES_LEVEL_MAX = 6670 + RET_PLANET_FES_EXCLUSIVE_EVENT = 6671 + RET_MARBLE_SEAL_ALREADY_UNLOCKED = 6701 + RET_MARBLE_SEAL_SHOP_ITEM_NOT_ENOUGH = 6702 + RET_MARBLE_SEAL_LOCKED = 6703 + RET_PARKOUR_ACTIVITY_NOT_OPEN = 6801 + RET_PARKOUR_LEVEL_NOT_UNLOCK = 6802 + RET_PARKOUR_RAIL_BALL_NOT_ALLOWED = 6803 + RET_PARKOUR_NOT_IN_LEVEL = 6804 + RET_PARKOUR_LEVEL_NOT_MATCH = 6805 + RET_PARKOUR_NOT_PLAYED_ALL_NON_STORY_LEVEL = 6806 + RET_FTC_LIMIT_NAME_CHANGE = 6830 + RET_GRID_FIGHT_CONF_MISS = 6900 + + +class TrialActivityStatus(betterproto.Enum): + TRIAL_ACTIVITY_STATUS_NONE = 0 + TRIAL_ACTIVITY_STATUS_FINISH = 1 + +class GBPHKKMOLMF(betterproto.Enum): + LEFT = 0 + RIGHT = 1 + UP = 2 + DOWN = 3 + LEFT_UP = 4 + LEFT_DOWN = 5 + RIGHT_UP = 6 + RIGHT_DOWN = 7 + + +class AlleyEventType(betterproto.Enum): + ALLEY_EVENT_TYPE_NONE = 0 + ALLEY_MAIN_EVENT = 1 + ALLEY_CRITICAL_EVENT = 2 + ALLEY_DAILY_EVENT = 3 + + +class AlleyEventState(betterproto.Enum): + ALLEY_STATE_NONE = 0 + ALLEY_EVENT_DOING = 1 + ALLEY_EVENT_FINISH = 2 + ALLEY_EVENT_REWARDED = 3 + +class GrowthTartgetFuncType(betterproto.Enum): + GROWTH_TARGET_FUNCTION_TYPE_INCLUDE_ALL_SKILLTREE = 0 + + +class AddAvatarSrcState(betterproto.Enum): + ADD_AVATAR_SRC_NONE = 0 + ADD_AVATAR_SRC_GACHA = 1 + ADD_AVATAR_SRC_ROGUE = 2 + + +class GrowthTargetState(betterproto.Enum): + GROWTH_TARGET_AVATAR_NONE = 0 + GROWTH_TARGET_AVATAR_PRE = 1 + GROWTH_TARGET_AVATAR_UP = 2 + GROWTH_TARGET_AVATAR_LOCK = 3 + GROWTH_TARGET_AVATAR_UNLOCK = 4 + GROWTH_TARGET_AVATAR_LOCK_AND_UP = 5 + +class BpTierType(betterproto.Enum): + BP_TIER_TYPE_NONE = 0 + BP_TIER_TYPE_FREE = 1 + BP_TIER_TYPE_PREMIUM_1 = 2 + BP_TIER_TYPE_PREMIUM_2 = 3 + + +class BpRewardType(betterproto.Enum): + BP_REWARAD_TYPE_NONE = 0 + BP_REWARAD_TYPE_FREE = 1 + BP_REWARAD_TYPE_PREMIUM_1 = 2 + BP_REWARAD_TYPE_PREMIUM_2 = 3 + BP_REWARAD_TYPE_PREMIUM_OPTIONAL = 4 + +class ChallengeStatus(betterproto.Enum): + CHALLENGE_UNKNOWN = 0 + CHALLENGE_DOING = 1 + CHALLENGE_FINISH = 2 + CHALLENGE_FAILED = 3 + +class ChessRogueDiceStatus(betterproto.Enum): + CHESS_ROGUE_DICE_IDLE = 0 + CHESS_ROGUE_DICE_ROLLED = 1 + CHESS_ROGUE_DICE_CONFIRMED = 2 + CHESS_ROGUE_DICE_GIVEUP = 3 + + +class ChessRogueDiceType(betterproto.Enum): + CHESS_ROGUE_DICE_FIXED = 0 + CHESS_ROGUE_DICE_EDITABLE = 1 + + +class ChessRogueBoardCellStatus(betterproto.Enum): + IDLE = 0 + SELECTED = 1 + PROCESSING = 2 + FINISH = 3 + + +class ChessRogueCellSpecialType(betterproto.Enum): + CHESS_ROGUE_CELL_SPECIAL_TYPE_NONE = 0 + CHESS_ROGUE_CELL_SPECIAL_TYPE_LOCKED = 1 + CHESS_ROGUE_CELL_SPECIAL_TYPE_REPLICATE = 2 + CHESS_ROGUE_CELL_SPECIAL_TYPE_PROTECTED = 3 + CHESS_ROGUE_CELL_SPECIAL_TYPE_SEED = 4 + CHESS_ROGUE_CELL_SPECIAL_TYPE_STAMP = 5 + + +class ChessRogueLevelStatus(betterproto.Enum): + CHESS_ROGUE_LEVEL_IDLE = 0 + CHESS_ROGUE_LEVEL_PROCESSING = 1 + CHESS_ROGUE_LEVEL_PENDING = 2 + CHESS_ROGUE_LEVEL_FINISH = 3 + CHESS_ROGUE_LEVEL_FAILED = 4 + CHESS_ROGUE_LEVEL_FORCE_FINISH = 5 + + +class ChessRogueQuitReason(betterproto.Enum): + CHESS_ROGUE_ACCOUNT_BY_NONE = 0 + CHESS_ROGUE_ACCOUNT_BY_NORMAL_FINISH = 1 + CHESS_ROGUE_ACCOUNT_BY_NORMAL_QUIT = 2 + CHESS_ROGUE_ACCOUNT_BY_DIALOG = 3 + CHESS_ROGUE_ACCOUNT_BY_FAILED = 4 + CHESS_ROGUE_ACCOUNT_BY_CUSTOM_OP = 5 + + +class ChessRogueBuffSourceType(betterproto.Enum): + CHESS_ROGUE_BUFF_SOURCE_TYPE_NONE = 0 + CHESS_ROGUE_BUFF_SOURCE_TYPE_SELECT = 1 + CHESS_ROGUE_BUFF_SOURCE_TYPE_ENHANCE = 2 + CHESS_ROGUE_BUFF_SOURCE_TYPE_MIRACLE = 3 + CHESS_ROGUE_BUFF_SOURCE_TYPE_DIALOGUE = 4 + CHESS_ROGUE_BUFF_SOURCE_TYPE_BONUS = 5 + CHESS_ROGUE_BUFF_SOURCE_TYPE_SHOP = 6 + CHESS_ROGUE_BUFF_SOURCE_TYPE_DICE = 7 + CHESS_ROGUE_BUFF_SOURCE_TYPE_AEON = 8 + CHESS_ROGUE_BUFF_SOURCE_TYPE_MAZE_SKILL = 9 + CHESS_ROGUE_BUFF_SOURCE_TYPE_LEVEL_MECHANISM = 10 + + +class ChessRogueMiracleSourceType(betterproto.Enum): + CHESS_ROGUE_MIRACLE_SOURCE_TYPE_NONE = 0 + CHESS_ROGUE_MIRACLE_SOURCE_TYPE_SELECT = 1 + CHESS_ROGUE_MIRACLE_SOURCE_TYPE_DIALOGUE = 2 + CHESS_ROGUE_MIRACLE_SOURCE_TYPE_BONUS = 3 + CHESS_ROGUE_MIRACLE_SOURCE_TYPE_USE = 4 + CHESS_ROGUE_MIRACLE_SOURCE_TYPE_RESET = 5 + CHESS_ROGUE_MIRACLE_SOURCE_TYPE_REPLACE = 6 + CHESS_ROGUE_MIRACLE_SOURCE_TYPE_TRADE = 7 + CHESS_ROGUE_MIRACLE_SOURCE_TYPE_GET = 8 + CHESS_ROGUE_MIRACLE_SOURCE_TYPE_SHOP = 9 + CHESS_ROGUE_MIRACLE_SOURCE_TYPE_MAZE_SKILL = 10 + CHESS_ROGUE_MIRACLE_SOURCE_TYPE_LEVEL_MECHANISM = 11 + + +class ChessRogueUpdateLevelStatus(betterproto.Enum): + CHESS_ROGUE_UPDATE_LEVEL_STATUS_BY_NONE = 0 + CHESS_ROGUE_UPDATE_LEVEL_STATUS_BY_DIALOG = 1 + + +class ChessRogueCellUpdateReason(betterproto.Enum): + CHESS_ROGUE_CELL_UPDATE_REASON_NONE = 0 + CHESS_ROGUE_CELL_UPDATE_REASON_MODIFIER = 1 + + +class ChessRogueAeonType(betterproto.Enum): + CHESS_ROGUE_AEON_TYPE_NONE = 0 + CHESS_ROGUE_AEON_TYPE_KNIGHT = 1 + CHESS_ROGUE_AEON_TYPE_MEMORY = 2 + CHESS_ROGUE_AEON_TYPE_WARLOCK = 3 + CHESS_ROGUE_AEON_TYPE_PRIEST = 4 + CHESS_ROGUE_AEON_TYPE_ROGUE = 5 + CHESS_ROGUE_AEON_TYPE_WARRIOR = 6 + CHESS_ROGUE_AEON_TYPE_HAPPY = 7 + CHESS_ROGUE_AEON_TYPE_BREED = 8 + + +class ChessRogueDiceSourceType(betterproto.Enum): + CHESS_ROGUE_DICE_SOURCE_TYPE_NONE = 0 + CHESS_ROGUE_DICE_SOURCE_TYPE_NORMAL = 1 + CHESS_ROGUE_DICE_SOURCE_TYPE_REPEAT = 2 + CHESS_ROGUE_DICE_SOURCE_TYPE_CHEAT = 3 + + +class ChessRogueNousMainStoryStatus(betterproto.Enum): + CHESS_ROGUE_NOUS_MAIN_STORY_STATUS_NONE = 0 + CHESS_ROGUE_NOUS_MAIN_STORY_STATUS_UNLOCK = 1 + CHESS_ROGUE_NOUS_MAIN_STORY_STATUS_FINISH = 2 + CHESS_ROGUE_NOUS_MAIN_STORY_STATUS_CAN_TRIGGER = 3 + + +class ChessRogueNousDicePhase(betterproto.Enum): + NONE = 0 + PHASE_ONE = 1 + PHASE_TWO = 2 + +class OAPDMKKKEOL(betterproto.Enum): + CHIMERA_LAST_PHASE_FINISH_NONE = 0 + CHIMERA_LAST_PHASE_FINISH_NORMAL = 1 + CHIMERA_LAST_PHASE_FINISH_SKIP = 2 + CHIMERA_LAST_PHASE_FINISH_FORCE = 3 + + +class BIAKDFELJFM(betterproto.Enum): + CHIMERA_ROUND_WORK_END_NONE = 0 + CHIMERA_ROUND_WORK_END_SUCC = 1 + CHIMERA_ROUND_WORK_END_FAIL = 2 + CHIMERA_ROUND_WORK_END_LEAVE = 3 + +class ClockParkPlayStatus(betterproto.Enum): + CLOCK_PARK_PLAY_NONE = 0 + CLOCK_PARK_PLAY_NORMAL_DEATH = 1 + CLOCK_PARK_PLAY_NORMAL_PASS = 2 + CLOCK_PARK_PLAY_FINISH_SCRIPT = 5 + + +class MissionStatus(betterproto.Enum): + MISSION_NONE = 0 + MISSION_DOING = 1 + MISSION_FINISH = 2 + MISSION_PREPARED = 3 + + +class MessageSectionStatus(betterproto.Enum): + MESSAGE_SECTION_NONE = 0 + MESSAGE_SECTION_DOING = 1 + MESSAGE_SECTION_FINISH = 2 + MESSAGE_SECTION_FROZEN = 3 + + +class MessageGroupStatus(betterproto.Enum): + MESSAGE_GROUP_NONE = 0 + MESSAGE_GROUP_DOING = 1 + MESSAGE_GROUP_FINISH = 2 + MESSAGE_GROUP_FROZEN = 3 + + +class BattleRecordType(betterproto.Enum): + BATTLE_RECORD_NONE = 0 + BATTLE_RECORD_CHALLENGE = 1 + BATTLE_RECORD_ROGUE = 2 + + +class RebattleType(betterproto.Enum): + REBATTLE_TYPE_NONE = 0 + REBATTLE_TYPE_REBATTLE_MIDWAY = 1 + REBATTLE_TYPE_REBATTLE_LOSE = 2 + REBATTLE_TYPE_REBATTLE_MIDWAY_LINEUP = 3 + REBATTLE_TYPE_REBATTLE_LOSE_LINEUP = 4 + REBATTLE_TYPE_QUIT_MIDWAY = 5 + REBATTLE_TYPE_QUIT_LOSE = 6 + + +class ContentPackageStatus(betterproto.Enum): + ContentPackageStatus_None = 0 + ContentPackageStatus_Init = 1 + ContentPackageStatus_Doing = 2 + ContentPackageStatus_Finished = 3 + ContentPackageStatus_Release = 4 + +class ServerLogTag(betterproto.Enum): + SERVER_LOG_TAG_DEFAULT = 0 + SERVER_LOG_TAG_ROGUE = 1 + SERVER_LOG_TAG_SCENE = 3 + SERVER_LOG_TAG_BATTLE = 4 + SERVER_LOG_TAG_CPP_GAMECORE = 5 + SERVER_LOG_TAG_LEVEL_GRAPH = 6 + SERVER_LOG_TAG_PLANET_FES = 7 + + +class ServerLogLevel(betterproto.Enum): + SERVER_LOG_LEVEL_NONE = 0 + SERVER_LOG_LEVEL_DEBUG = 1 + SERVER_LOG_LEVEL_INFO = 2 + SERVER_LOG_LEVEL_WARN = 3 + SERVER_LOG_LEVEL_ERROR = 4 + + +class OJIDJNDHDGA(betterproto.Enum): + READY = 0 + SUSPEND = 1 + SUCC = 2 + FAIL = 3 + +class OIJLBLOOHJG(betterproto.Enum): + EVOLVE_PERIOD_NONE = 0 + EVOLVE_PERIOD_FIRST = 1 + EVOLVE_PERIOD_SECOND = 2 + EVOLVE_PERIOD_THIRD = 3 + EVOLVE_PERIOD_EXTRA = 4 + + +class DLHCMCNIHII(betterproto.Enum): + EVOLVE_BATTLE_RESULT_NONE = 0 + EVOLVE_BATTLE_RESULT_WIN = 1 + EVOLVE_BATTLE_RESULT_ALL_AVATAR_DEAD = 2 + EVOLVE_BATTLE_RESULT_NO_DEAD_LINE = 3 + EVOLVE_BATTLE_RESULT_QUIT = 4 + + +class KLNIPNJCNMJ(betterproto.Enum): + EVOLVE_BUILD_SEASON_NONE = 0 + EVOLVE_BUILD_EARLY_ACCESS = 1 + EVOLVE_BUILD_SECOND_CHAPTER = 2 + +class FeverTimeBattleRank(betterproto.Enum): + FEVER_TIME_BATTLE_RANK_C = 0 + FEVER_TIME_BATTLE_RANK_B = 1 + FEVER_TIME_BATTLE_RANK_A = 2 + FEVER_TIME_BATTLE_RANK_S = 3 + FEVER_TIME_BATTLE_RANK_SS = 4 + +class HGDAPJPKFFB(betterproto.Enum): + FIGHT_FEST_BATTLE_RANK_C = 0 + FIGHT_FEST_BATTLE_RANK_B = 1 + FIGHT_FEST_BATTLE_RANK_A = 2 + FIGHT_FEST_BATTLE_RANK_S = 3 + FIGHT_FEST_BATTLE_RANK_SS = 4 + + +class APLOAGDIBKI(betterproto.Enum): + FIGHT_FEST_TYPE_NONE = 0 + FIGHT_FEST_TYPE_MAIN = 1 + FIGHT_FEST_TYPE_SCORE = 2 + FIGHT_FEST_TYPE_CHALLENGE = 3 + FIGHT_FEST_TYPE_TEACH = 4 + +class MJBIKBCPKAI(betterproto.Enum): + FightMarbleEventTypeNone = 0 + FightMarbleEventTypePlayerEnd = 1 + FightMarbleEventTypeGameEnd = 2 + + +class JOMKPEGEFMP(betterproto.Enum): + MARBLE_TEAM_TYPE_NONE = 0 + MARBLE_TEAM_TYPE_TEAM_A = 1 + MARBLE_TEAM_TYPE_TEAM_B = 2 + + +class EEIBHJPNJCF(betterproto.Enum): + MARBLE_PLAYER_STATE_Default = 0 + MARBLE_PLAYER_STATE_Leave = 1 + MARBLE_PLAYER_STATE_KickOut = 2 + + +class IMPKPKAMIAF(betterproto.Enum): + MARBLE_SYNC_TYPE_NONE = 0 + MARBLE_SYNC_TYPE_LOADING = 1 + MARBLE_SYNC_TYPE_PERFORMANCE = 2 + MARBLE_SYNC_TYPE_ROUND_START = 3 + MARBLE_SYNC_TYPE_ROUND_END = 4 + MARBLE_SYNC_TYPE_SWITCH_ROUND = 6 + MARBLE_SYNC_TYPE_USE_TECH = 7 + MARBLE_SYNC_TYPE_SIMULATE_START = 8 + MARBLE_SYNC_TYPE_EMOJI = 9 + MARBLE_SYNC_TYPE_ACHIEVEMENT = 10 + + +class PAJNHIAGODD(betterproto.Enum): + MARBLE_FRAME_TYPE_NONE = 0 + MARBLE_FRAME_TYPE_ACTION_START = 1 + MARBLE_FRAME_TYPE_ACTION_END = 2 + MARBLE_FRAME_TYPE_ROUND_START = 3 + MARBLE_FRAME_TYPE_ROUND_END = 4 + MARBLE_FRAME_TYPE_REVIVE = 5 + MARBLE_FRAME_TYPE_HP_CHANGE = 6 + MARBLE_FRAME_TYPE_LAUNCH = 7 + MARBLE_FRAME_TYPE_STOP = 8 + MARBLE_FRAME_TYPE_COLLIDE = 9 + MARBLE_FRAME_TYPE_EFFECT = 10 + MARBLE_FRAME_TYPE_BUFF_TEXT = 11 + MARBLE_FRAME_TYPE_SKILL_UI = 12 + MARBLE_FRAME_TYPE_ABSORB = 13 + MARBLE_FRAME_TYPE_ON_OFF_FIELD = 14 + MARBLE_FRAME_TYPE_DEAD = 15 + MARBLE_FRAME_TYPE_USE_TECH = 16 + MARBLE_FRAME_TYPE_TECH_ACTIVE = 17 + MARBLE_FRAME_TYPE_GHOST_FIRE = 18 + MARBLE_FRAME_TYPE_TRIGGER = 19 + MARBLE_FRAME_TYPE_SWALLOW = 20 + MARBLE_FRAME_TYPE_RADIUS = 21 + MARBLE_FRAME_TYPE_HIDE_LINE = 22 + MARBLE_FRAME_TYPE_TEAM_SCORE = 23 + MARBLE_FRAME_TYPE_EMOJI_PACKAGE = 24 + MARBLE_FRAME_TYPE_CHANGE_SPEED = 25 + MARBLE_FRAME_TYPE_ADD_SHIELD = 26 + + +class LKKAJCACIJI(betterproto.Enum): + MARBLE_FACTION_TYPE_NONE = 0 + MARBLE_FACTION_TYPE_ALL = 1 + MARBLE_FACTION_TYPE_ENEMY = 2 + MARBLE_FACTION_TYPE_ALLY = 3 + MARBLE_FACTION_TYPE_FIELD = 4 + + +class FIPPKLCOEGJ(betterproto.Enum): + MARBLE_HP_CHANGE_TYPE_NONE = 0 + MARBLE_HP_CHANGE_TYPE_CRITICAL = 1 + MARBLE_HP_CHANGE_TYPE_SPINE = 2 + + +class PPIFFKJEJJA(betterproto.Enum): + Marble_Game_Phase_None = 0 + Marble_Game_Phase_Ready = 1 + Marble_Game_Phase_Delay = 2 + Marble_Game_Phase_Loading = 3 + Marble_Game_Phase_LoadFinish = 4 + Marble_Game_Phase_Performance = 5 + Marble_Game_Phase_PerformanceFinish = 6 + Marble_Game_Phase_RoundA = 7 + Marble_Game_Phase_RoundB = 8 + Marble_Game_Phase_Simulate = 9 + Marble_Game_Phase_SimulateFinish = 10 + Marble_Game_Phase_Tech = 11 + Marble_Game_Phase_TechUI = 12 + Marble_Game_Phase_TechFinish = 13 + Marble_Game_Phase_Finish = 14 + Marble_Game_Phase_PreRound = 15 + +class DGFCBOFAOIA(betterproto.Enum): + MATCH3_STATE_IDLE = 0 + MATCH3_STATE_START = 1 + MATCH3_STATE_MATCH = 2 + MATCH3_STATE_GAME = 3 + MATCH3_STATE_HALFTIME = 4 + MATCH3_STATE_OVER = 5 + + +class NPPNFPPENMC(betterproto.Enum): + MATCH3_PLAYER_STATE_ALIVE = 0 + MATCH3_PLAYER_STATE_DYING = 1 + MATCH3_PLAYER_STATE_DEAD = 2 + MATCH3_PLAYER_STATE_LEAVE = 3 + + +class BFILLIOBMFN(betterproto.Enum): + EVENT_BEGIN = 0 + EVENT_BREAK = 1 + EVENT_FALL = 2 + EVENT_REFRESH = 3 + EVENT_BIRD_SKILL = 4 + EVENT_ENV = 5 + EVENT_SHUFFLE = 6 + EVENT_SETTLE_TAG = 7 + +class FriendOnlineStatus(betterproto.Enum): + FRIEND_ONLINE_STATUS_OFFLINE = 0 + FRIEND_ONLINE_STATUS_ONLINE = 1 + +class FriendApplySource(betterproto.Enum): + FRIEND_APPLY_SOURCE_NONE = 0 + FRIEND_APPLY_SOURCE_SEARCH = 1 + FRIEND_APPLY_SOURCE_RECOMMEND = 2 + FRIEND_APPLY_SOURCE_ASSIST = 3 + FRIEND_APPLY_SOURCE_RECOMMEND_ASSIST = 4 + FRIEND_APPLY_SOURCE_PSN_FRIEND = 5 + FRIEND_APPLY_SOURCE_ASSIST_REWARD = 6 + +class HeartDialEmotionType(betterproto.Enum): + HEART_DIAL_EMOTION_TYPE_PEACE = 0 + HEART_DIAL_EMOTION_TYPE_ANGER = 1 + HEART_DIAL_EMOTION_TYPE_HAPPY = 2 + HEART_DIAL_EMOTION_TYPE_SAD = 3 + + +class HeartDialStepType(betterproto.Enum): + HEART_DIAL_STEP_TYPE_MISSING = 0 + HEART_DIAL_STEP_TYPE_FULL = 1 + HEART_DIAL_STEP_TYPE_LOCK = 2 + HEART_DIAL_STEP_TYPE_UNLOCK = 3 + HEART_DIAL_STEP_TYPE_NORMAL = 4 + HEART_DIAL_STEP_TYPE_CONTROL = 5 + + +class HeartDialUnlockStatus(betterproto.Enum): + HEART_DIAL_UNLOCK_STATUS_LOCK = 0 + HEART_DIAL_UNLOCK_STATUS_UNLOCK_SINGLE = 1 + HEART_DIAL_UNLOCK_STATUS_UNLOCK_ALL = 2 + +class ICPINEHOLML(betterproto.Enum): + RELIC_DISCARD_TYPE_SINGLE = 0 + RELIC_DISCARD_TYPE_BATCH = 1 + RELIC_DISCARD_TYPE_SMART = 2 + + +class TurnFoodSwitch(betterproto.Enum): + TURN_FOOD_SWITCH_NONE = 0 + TURN_FOOD_SWITCH_ATTACK = 1 + TURN_FOOD_SWITCH_DEFINE = 2 + +class PBPAHLPFNDA(betterproto.Enum): + LINEUP_TYPE_NONE = 0 + LINEUP_TYPE_PRESET = 1 + LINEUP_TYPE_VIRTUAL = 2 + LINEUP_TYPE_EXTRA = 3 + LINEUP_TYPE_STORY_LINE = 4 + + +class ExtraLineupType(betterproto.Enum): + LINEUP_NONE = 0 + LINEUP_CHALLENGE = 1 + LINEUP_ROGUE = 2 + LINEUP_CHALLENGE_2 = 3 + LINEUP_CHALLENGE_3 = 4 + LINEUP_ROGUE_CHALLENGE = 5 + LINEUP_STAGE_TRIAL = 6 + LINEUP_ROGUE_TRIAL = 7 + LINEUP_ACTIVITY = 8 + LINEUP_BOXING_CLUB = 9 + LINEUP_TREASURE_DUNGEON = 11 + LINEUP_CHESS_ROGUE = 12 + LINEUP_HELIOBUS = 13 + LINEUP_TOURN_ROGUE = 14 + LINEUP_RELIC_ROGUE = 15 + LINEUP_ARCADE_ROGUE = 16 + LINEUP_MAGIC_ROGUE = 17 + + +class SyncLineupReason(betterproto.Enum): + SYNC_REASON_NONE = 0 + SYNC_REASON_MP_ADD = 1 + SYNC_REASON_MP_ADD_PROP_HIT = 2 + SYNC_REASON_HP_ADD = 3 + SYNC_REASON_HP_ADD_PROP_HIT = 4 + +class MailType(betterproto.Enum): + MAIL_TYPE_NORMAL = 0 + MAIL_TYPE_STAR = 1 + +class AJDDHBHMOOF(betterproto.Enum): + MatchThreeStatistics_None = 0 + MatchThreeStatistics_First = 1 + MatchThreeStatistics_Second = 2 + MatchThreeStatistics_Third = 3 + MatchThreeStatistics_Fruit = 4 + MatchThreeStatistics_Skill = 5 + MatchThreeStatistics_Defeat = 6 + MatchThreeStatistics_Bomb = 7 + MatchThreeStatistics_Damage = 8 + MatchThreeStatistics_Energy = 9 + MatchThreeStatistics_SwapBomb = 10 + +class CancelCacheType(betterproto.Enum): + CACHE_NOTIFY_TYPE_NONE = 0 + CACHE_NOTIFY_TYPE_RECYCLE = 1 + CACHE_NOTIFY_TYPE_RECHARGE = 2 + + +class MovieRacingType(betterproto.Enum): + MOVIE_RACING_OVER_TAKE = 0 + MOVIE_RACING_OVER_TAKE_ENDLESS = 1 + MOVIE_RACING_SHOOTING = 2 + MOVIE_RACING_SHOOTING_ENDLESS = 3 + + +class DifficultyAdjustmentType(betterproto.Enum): + DIFFICULTY_AJUSTMENT_TYPE_DEFAULT = 0 + DIFFICULTY_AJUSTMENT_TYPE_EASY = 1 + + +class GIILENMKCAH(betterproto.Enum): + DIFFICULTY_AJUSTMENT_SOURCE_NONE = 0 + DIFFICULTY_AJUSTMENT_SOURCE_RAID = 1 + DIFFICULTY_AJUSTMENT_SOURCE_EVENT = 2 + + +class MNIJHMEPGNN(betterproto.Enum): + MAZE_KILL_SOURCE_NONE = 0 + MAZE_KILL_SOURCE_SWITCH_HAND = 1 + MAZE_KILL_SOURCE_TIME_LINE = 2 + +class MissionSyncRecord(betterproto.Enum): + MISSION_SYNC_RECORD_NONE = 0 + MISSION_SYNC_RECORD_MAIN_MISSION_ACCEPT = 1 + MISSION_SYNC_RECORD_MAIN_MISSION_START = 2 + MISSION_SYNC_RECORD_MAIN_MISSION_FINISH = 3 + MISSION_SYNC_RECORD_MAIN_MISSION_DELETE = 4 + MISSION_SYNC_RECORD_MISSION_ACCEPT = 11 + MISSION_SYNC_RECORD_MISSION_START = 12 + MISSION_SYNC_RECORD_MISSION_FINISH = 13 + MISSION_SYNC_RECORD_MISSION_DELETE = 14 + MISSION_SYNC_RECORD_MISSION_PROGRESS = 15 + + +class GJPKMNEFCFO(betterproto.Enum): + MAIN_MISSION_SYNC_NONE = 0 + MAIN_MISSION_SYNC_MCV = 1 + + +class TrackMainMissionUpdateReasonId(betterproto.Enum): + TRACK_MAIN_MISSION_UPDATE_NONE = 0 + TRACK_MAIN_MISSION_UPDATE_AUTO = 1 + TRACK_MAIN_MISSION_UPDATE_MANUAL = 2 + TRACK_MAIN_MISSION_UPDATE_LOGIN_REPORT = 3 + +class GOJOINDBKIK(betterproto.Enum): + MONOPOLY_SOCIAL_EVENT_STATUS_NONE = 0 + MONOPOLY_SOCIAL_EVENT_STATUS_WAITING_SELECT_FRIEND = 1 + + +class IHGJLLNGDKL(betterproto.Enum): + MONOPOLY_CELL_STATE_IDLE = 0 + MONOPOLY_CELL_STATE_BARRIER = 1 + MONOPOLY_CELL_STATE_GROUND = 2 + MONOPOLY_CELL_STATE_FINISH = 3 + + +class GKEJFKAKENM(betterproto.Enum): + MONOPOLY_ACTION_RESULT_SOURCE_TYPE_NONE = 0 + MONOPOLY_ACTION_RESULT_SOURCE_TYPE_EFFECT = 1 + MONOPOLY_ACTION_RESULT_SOURCE_TYPE_ASSET_BONUS = 2 + MONOPOLY_ACTION_RESULT_SOURCE_TYPE_ASSET_TAX = 3 + MONOPOLY_ACTION_RESULT_SOURCE_TYPE_ASSET_UPGRADE = 4 + MONOPOLY_ACTION_RESULT_SOURCE_TYPE_GAME_SETTLE = 5 + MONOPOLY_ACTION_RESULT_SOURCE_TYPE_BUY_GOODS = 6 + MONOPOLY_ACTION_RESULT_SOURCE_TYPE_CLICK = 7 + MONOPOLY_ACTION_RESULT_SOURCE_TYPE_SOCIAL_EVENT = 8 + MONOPOLY_ACTION_RESULT_SOURCE_TYPE_LIKE = 9 + MONOPOLY_ACTION_RESULT_SOURCE_TYPE_QUIZ_GAME_SETTLE = 10 + +class AIHADKBHPBM(betterproto.Enum): + MUSEUM_RANDOM_EVENT_STATE_NONE = 0 + MUSEUM_RANDOM_EVENT_STATE_START = 1 + MUSEUM_RANDOM_EVENT_STATE_PROCESSING = 2 + MUSEUM_RANDOM_EVENT_STATE_FINISH = 3 + + +class KAMLGLMNJGJ(betterproto.Enum): + WORK_POS_NONE = 0 + WORK_POS_1 = 1 + WORK_POS_2 = 2 + WORK_POS_3 = 3 + + +class IBBGDGGHEJL(betterproto.Enum): + STAT_TYPE_NONE = 0 + STAT_TYPE_ART = 1 + STAT_TYPE_CULTURE = 2 + STAT_TYPE_POPULAR = 3 + + +class KGJJJKPDCFG(betterproto.Enum): + UNKNOW = 0 + MISSION_REWARD = 1 + EVENT_BUY_STUFF = 2 + MARKET_BUY_STUFF = 3 + QUEST_REWARD = 4 + INITIAL = 5 + PHASE_FINISH_REWARD = 6 + +class EPGDHHHDJDC(betterproto.Enum): + STATUS_CLOSE = 0 + STATUS_OPEN = 1 + +class OfferingState(betterproto.Enum): + OFFERING_STATE_NONE = 0 + OFFERING_STATE_LOCK = 1 + OFFERING_STATE_OPEN = 2 + +class POAHABDKPKJ(betterproto.Enum): + PARKOUR_END_LEVEL_REASON_NONE = 0 + PARKOUR_END_LEVEL_REASON_FINISH = 1 + PARKOUR_END_LEVEL_REASON_QUIT = 2 + + +class HCFFFEIMCMF(betterproto.Enum): + PARKOUR_LEVEL_STT_NONE = 0 + PARKOUR_LEVEL_STT_BOMBED_BY_SPARKLE_FIGURE = 1 + PARKOUR_LEVEL_STT_DESTROY_SPARKLE_FIGURE = 2 + +class CDEFBKPCPPA(betterproto.Enum): + PET_OPERATION_TYPE_NONE = 0 + PET_OPERATION_TYPE_SUMMON = 1 + PET_OPERATION_TYPE_RECALL = 2 + +class GMFEJEFIBBI(betterproto.Enum): + PLANET_FES_QUEST_NONE = 0 + PLANET_FES_QUEST_DOING = 1 + PLANET_FES_QUEST_FINISH = 2 + PLANET_FES_QUEST_CLOSE = 3 + + +class DFHEJCIJBEJ(betterproto.Enum): + PLANET_FES_BUSINESS_EVENT_CHANGE_REASON_NONE = 0 + PLANET_FES_BUSINESS_EVENT_AVATAR_CHANGE = 1 + PLANET_FES_BUSINESS_EVENT_FINISH_GAME = 2 + + +class IOCPJFKGKDG(betterproto.Enum): + PLANET_FES_CUSTOM_KEY_NONE = 0 + PLANET_FES_CUSTOM_KEY_UNLOCK_INFINITE_BUSINESS_DAY_PERFORMANCE = 1 + PLANET_FES_CUSTOM_KEY_BUSINESS_DAY_START_PERFORMANCE_LAST_SEEN_DAY = 2 + PLANET_FES_CUSTOM_KEY_BUSINESS_DAY_UNLOCK_PERFORMANCE_LAST_SEEN_DAY = 3 + PLANET_FES_CUSTOM_KEY_SUMMARY_SHOW = 4 + +class AOPKIFDMADI(betterproto.Enum): + PLANET_FES_LARGE_BONUS_INTERACT_START = 0 + PLANET_FES_LARGE_BONUS_INTERACT_REPORT = 1 + PLANET_FES_LARGE_BONUS_INTERACT_FINISH = 2 + +class ILPMNLDGEAK(betterproto.Enum): + AUTHKEY_SIGN_TYPE_NONE = 0 + AUTHKEY_SIGN_TYPE_DEFAULT = 1 + AUTHKEY_SIGN_TYPE_RSA = 2 + +class NOBPMMNFENJ(betterproto.Enum): + PLAYER_RETURN_NONE = 0 + PLAYER_RETURN_PROCESSING = 1 + PLAYER_RETURN_FINISH = 2 + +class NLEFPBICECN(betterproto.Enum): + PUNK_LORD_OPERATION_NONE = 0 + PUNK_LORD_OPERATION_REFRESH = 1 + PUNK_LORD_OPERATION_SHARE = 2 + PUNK_LORD_OPERATION_START_RAID = 3 + PUNK_LORD_OPERATION_GET_BATTLE_RECORD = 4 + +class QuestStatus(betterproto.Enum): + QUEST_NONE = 0 + QUEST_DOING = 1 + QUEST_FINISH = 2 + QUEST_CLOSE = 3 + QUEST_DELETE = 4 + +class RaidStatus(betterproto.Enum): + RAID_STATUS_NONE = 0 + RAID_STATUS_DOING = 1 + RAID_STATUS_FINISH = 2 + RAID_STATUS_FAILED = 3 + + +class FOCHDFJANPC(betterproto.Enum): + RAID_TARGET_STATUS_NONE = 0 + RAID_TARGET_STATUS_DOING = 1 + RAID_TARGET_STATUS_FINISH = 2 + + +class EGKFNDOOPNN(betterproto.Enum): + RAID_KICK_REASON_NONE = 0 + RAID_KICK_REASON_ACTIVITY_SCHEDULE_FINISH = 1 + +class BigDataRecommendType(betterproto.Enum): + BIG_DATA_RECOMMEND_TYPE_NONE = 0 + BIG_DATA_RECOMMEND_TYPE_EQUIPMENT = 1 + BIG_DATA_RECOMMEND_TYPE_RELIC_SUIT = 2 + BIG_DATA_RECOMMEND_TYPE_RELIC_AVATAR = 3 + BIG_DATA_RECOMMEND_TYPE_AVATAR_RELIC = 4 + BIG_DATA_RECOMMEND_TYPE_LOCAL_LEGEND = 5 + +class OJLJHFNFDKP(betterproto.Enum): + UPDATE_REDDOT_NONE = 0 + UPDATE_REDDOT_ADD = 1 + UPDATE_REDDOT_REPLACE = 2 + +class RogueStatus(betterproto.Enum): + ROGUE_STATUS_NONE = 0 + ROGUE_STATUS_DOING = 1 + ROGUE_STATUS_PENDING = 2 + ROGUE_STATUS_ENDLESS = 3 + ROGUE_STATUS_FINISH = 4 + + +class RogueRoomStatus(betterproto.Enum): + ROGUE_ROOM_STATUS_NONE = 0 + ROGUE_ROOM_STATUS_LOCK = 1 + ROGUE_ROOM_STATUS_UNLOCK = 2 + ROGUE_ROOM_STATUS_PLAY = 3 + ROGUE_ROOM_STATUS_FINISH = 4 + + +class RogueAreaStatus(betterproto.Enum): + ROGUE_AREA_STATUS_LOCK = 0 + ROGUE_AREA_STATUS_UNLOCK = 1 + ROGUE_AREA_STATUS_FIRST_PASS = 2 + ROGUE_AREA_STATUS_CLOSE = 3 + + +class RogueBuffSourceType(betterproto.Enum): + ROGUE_BUFF_SOURCE_TYPE_NONE = 0 + ROGUE_BUFF_SOURCE_TYPE_SELECT = 1 + ROGUE_BUFF_SOURCE_TYPE_ENHANCE = 2 + ROGUE_BUFF_SOURCE_TYPE_MIRACLE = 3 + ROGUE_BUFF_SOURCE_TYPE_DIALOGUE = 4 + ROGUE_BUFF_SOURCE_TYPE_BONUS = 5 + ROGUE_BUFF_SOURCE_TYPE_MAZE_SKILL = 6 + ROGUE_BUFF_SOURCE_TYPE_SHOP = 7 + ROGUE_BUFF_SOURCE_TYPE_LEVEL_MECHANISM = 8 + ROGUE_BUFF_SOURCE_TYPE_ENDLESS_LEVEL_START = 9 + + +class RogueMiracleSourceType(betterproto.Enum): + ROGUE_MIRACLE_SOURCE_TYPE_NONE = 0 + ROGUE_MIRACLE_SOURCE_TYPE_SELECT = 1 + ROGUE_MIRACLE_SOURCE_TYPE_DIALOGUE = 2 + ROGUE_MIRACLE_SOURCE_TYPE_BONUS = 3 + ROGUE_MIRACLE_SOURCE_TYPE_USE = 4 + ROGUE_MIRACLE_SOURCE_TYPE_RESET = 5 + ROGUE_MIRACLE_SOURCE_TYPE_REPLACE = 6 + ROGUE_MIRACLE_SOURCE_TYPE_TRADE = 7 + ROGUE_MIRACLE_SOURCE_TYPE_GET = 8 + ROGUE_MIRACLE_SOURCE_TYPE_SHOP = 9 + ROGUE_MIRACLE_SOURCE_TYPE_MAZE_SKILL = 10 + ROGUE_MIRACLE_SOURCE_TYPE_LEVEL_MECHANISM = 11 + ROGUE_MIRACLE_SOURCE_TYPE_ENDLESS_LEVEL_START = 12 + + +class RogueDialogueResult(betterproto.Enum): + ROGUE_DIALOGUE_RESULT_SUCC = 0 + ROGUE_DIALOGUE_RESULT_FAIL = 1 + +class RogueAdventureRoomStatus(betterproto.Enum): + ROGUE_ADVENTURE_ROOM_STATUS_NONE = 0 + ROGUE_ADVENTURE_ROOM_STATUS_PREPARE = 1 + ROGUE_ADVENTURE_ROOM_STATUS_STARTED = 2 + ROGUE_ADVENTURE_ROOM_STATUS_STOPPED = 3 + + +class RogueCommonBuffSelectSourceType(betterproto.Enum): + ROGUE_COMMON_BUFF_SELECT_SOURCE_TYPE_NONE = 0 + ROGUE_COMMON_BUFF_SELECT_SOURCE_TYPE_DICE_ROLL = 1 + ROGUE_COMMON_BUFF_SELECT_SOURCE_TYPE_AEON = 2 + ROGUE_COMMON_BUFF_SELECT_SOURCE_TYPE_BOARD_EVENT = 3 + ROGUE_COMMON_BUFF_SELECT_SOURCE_TYPE_LEVEL_MECHANISM = 4 + + +class RogueUnlockFunctionType(betterproto.Enum): + ROGUE_UNLOCK_FUNCTION_TYPE_MIRACLE = 0 + ROGUE_UNLOCK_FUNCTION_TYPE_SHOW_HINT = 1 + ROGUE_UNLOCK_FUNCTION_TYPE_COSMOS_BAN_AEON = 2 + ROGUE_UNLOCK_FUNTION_TYPE_EXHIBITION = 3 + ROGUE_UNLOCK_FUNTION_TYPE_COLLECTION = 4 + ROGUE_UNLOCK_FUNTION_TYPE_TOURN_GOD_MODE = 5 + + +class RogueCommonMiracleSelectSourceType(betterproto.Enum): + ROGUE_COMMON_MIRACLE_SELECT_SOURCE_TYPE_NONE = 0 + ROGUE_COMMON_MIRACLE_SELECT_SOURCE_TYPE_DICE_ROLL = 1 + ROGUE_COMMON_MIRACLE_SELECT_SOURCE_TYPE_AEON = 2 + ROGUE_COMMON_MIRACLE_SELECT_SOURCE_TYPE_BOARD_EVENT = 3 + ROGUE_COMMON_MIRACLE_SELECT_SOURCE_TYPE_LEVEL_MECHANISM = 4 + + +class RogueCommonBuffDisplayType(betterproto.Enum): + ROGUE_COMMON_BUFF_DISPLAY_TYPE_NONE = 0 + ROGUE_COMMON_BUFF_DISPLAY_TYPE_ADD = 1 + ROGUE_COMMON_BUFF_DISPLAY_TYPE_REMOVE = 2 + + +class RogueCommonMiracleDisplayType(betterproto.Enum): + ROGUE_COMMON_MIRACLE_DISPLAY_TYPE_NONE = 0 + ROGUE_COMMON_MIRACLE_DISPLAY_TYPE_ADD = 1 + ROGUE_COMMON_MIRACLE_DISPLAY_TYPE_REMOVE = 2 + ROGUE_COMMON_MIRACLE_DISPLAY_TYPE_REPAIR = 3 + + +class RogueCommonItemDisplayType(betterproto.Enum): + ROGUE_COMMON_ITEM_DISPLAY_TYPE_NONE = 0 + ROGUE_COMMON_ITEM_DISPLAY_TYPE_ADD = 1 + ROGUE_COMMON_ITEM_DISPLAY_TYPE_REMOVE = 2 + + +class RogueCommonActionResultDisplayType(betterproto.Enum): + ROGUE_COMMON_ACTION_RESULT_DISPLAY_TYPE_NONE = 0 + ROGUE_COMMON_ACTION_RESULT_DISPLAY_TYPE_SINGLE = 1 + ROGUE_COMMON_ACTION_RESULT_DISPLAY_TYPE_MULTI = 2 + + +class RogueCommonActionResultSourceType(betterproto.Enum): + ROGUE_COMMON_ACTION_RESULT_SOURCE_TYPE_NONE = 0 + ROGUE_COMMON_ACTION_RESULT_SOURCE_TYPE_SELECT = 1 + ROGUE_COMMON_ACTION_RESULT_SOURCE_TYPE_ENHANCE = 2 + ROGUE_COMMON_ACTION_RESULT_SOURCE_TYPE_MIRACLE = 3 + ROGUE_COMMON_ACTION_RESULT_SOURCE_TYPE_DIALOGUE = 4 + ROGUE_COMMON_ACTION_RESULT_SOURCE_TYPE_BONUS = 5 + ROGUE_COMMON_ACTION_RESULT_SOURCE_TYPE_SHOP = 6 + ROGUE_COMMON_ACTION_RESULT_SOURCE_TYPE_DICE = 7 + ROGUE_COMMON_ACTION_RESULT_SOURCE_TYPE_AEON = 8 + ROGUE_COMMON_ACTION_RESULT_SOURCE_TYPE_BOARD_EVENT = 9 + ROGUE_COMMON_ACTION_RESULT_SOURCE_TYPE_MAZE_SKILL = 10 + ROGUE_COMMON_ACTION_RESULT_SOURCE_TYPE_LEVEL_MECHANISM = 11 + ROGUE_COMMON_ACTION_RESULT_SOURCE_TYPE_BUFF = 12 + ROGUE_COMMON_ACTION_RESULT_SOURCE_TYPE_REFORGE = 13 + ROGUE_COMMON_ACTION_RESULT_SOURCE_TYPE_MAGIC_UNIT_COMPOSE = 14 + ROGUE_COMMON_ACTION_RESULT_SOURCE_TYPE_MAGIC_UNIT_REFORGE = 15 + + +class NDKLJJIIMGM(betterproto.Enum): + kTitanBlessSelectNone = 0 + kSelectTitanBlessType = 1 + kSelectTitanBlessEnhance = 2 + + +class RogueTalentStatus(betterproto.Enum): + ROGUE_TALENT_STATUS_LOCK = 0 + ROGUE_TALENT_STATUS_UNLOCK = 1 + ROGUE_TALENT_STATUS_ENABLE = 2 + + +class RogueCollectionExhibitionOperateType(betterproto.Enum): + ROGUE_COLLECTION_OPERATE_NONE = 0 + ROGUE_COLLECTION_OPERATE_SET = 1 + ROGUE_COLLECTION_OPERATE_UNSET = 2 + + +class RogueBoothStatus(betterproto.Enum): + ROGUE_BOOTH_NONE = 0 + ROGUE_BOOTH_EMPTY = 1 + ROGUE_BOOTH_DISPLAY = 2 + + +class RogueCollectionStatus(betterproto.Enum): + ROGUE_COLLECTION_NONE = 0 + ROGUE_COLLECTION_UNLOCKED = 1 + ROGUE_COLLECTION_DISPLAY = 2 + + +class RogueExhibitionStatus(betterproto.Enum): + ROGUE_EXHIBITION_NONE = 0 + ROGUE_EXHIBITION_UNLOCKED = 1 + ROGUE_EXHIBITION_DISPLAY = 2 + +class RogueMagicLevelStatus(betterproto.Enum): + ROGUE_MAGIC_LEVEL_STATUS_NONE = 0 + ROGUE_MAGIC_LEVEL_STATUS_PROCESSING = 1 + ROGUE_MAGIC_LEVEL_STATUS_FINISHED = 2 + ROGUE_MAGIC_LEVEL_STATUS_SETTLED = 3 + + +class RogueMagicLayerStatus(betterproto.Enum): + ROGUE_MAGIC_LAYER_STATUS_NONE = 0 + ROGUE_MAGIC_LAYER_STATUS_PROCESSING = 1 + ROGUE_MAGIC_LAYER_STATUS_FINISH = 2 + + +class RogueMagicRoomStatus(betterproto.Enum): + ROGUE_MAGIC_ROOM_STATUS_NONE = 0 + ROGUE_MAGIC_ROOM_STATUS_INITED = 1 + ROGUE_MAGIC_ROOM_STATUS_PROCESSING = 2 + ROGUE_MAGIC_ROOM_STATUS_FINISH = 3 + + +class RogueMagicSettleReason(betterproto.Enum): + ROGUE_MAGIC_SETTLE_REASON_NONE = 0 + ROGUE_MAGIC_SETTLE_REASON_WIN = 1 + ROGUE_MAGIC_SETTLE_REASON_FAIL = 2 + ROGUE_MAGIC_SETTLE_REASON_INTERRUPT = 3 + +class RogueModifierSourceType(betterproto.Enum): + ROGUE_MODIFIER_SOURCE_NONE = 0 + ROGUE_MODIFIER_SOURCE_DICE_ROLL = 1 + ROGUE_MODIFIER_SOURCE_AEON = 2 + ROGUE_MODIFIER_SOURCE_BOARD_EVENT = 3 + ROGUE_MODIFIER_SOURCE_DIALOG_EVENT = 4 + ROGUE_MODIFIER_SOURCE_MIRACLE = 5 + ROGUE_MODIFIER_SOURCE_CELL_MARK = 6 + ROGUE_MODIFIER_SOURCE_AEON_TALENT = 7 + ROGUE_MODIFIER_SOURCE_BOSS_DECAY = 8 + ROGUE_MODIFIER_SOURCE_DICE_BRANCH = 9 + + +class RogueModifierContentType(betterproto.Enum): + ROGUE_MODIFIER_CONTENT_DEFINITE = 0 + ROGUE_MODIFIER_CONTENT_RANDOM = 1 + +class RogueTournLevelStatus(betterproto.Enum): + ROGUE_TOURN_LEVEL_STATUS_NONE = 0 + ROGUE_TOURN_LEVEL_STATUS_PROCESSING = 1 + ROGUE_TOURN_LEVEL_STATUS_FINISHED = 2 + ROGUE_TOURN_LEVEL_STATUS_SETTLED = 3 + + +class RogueTournLayerStatus(betterproto.Enum): + ROGUE_TOURN_LAYER_STATUS_NONE = 0 + ROGUE_TOURN_LAYER_STATUS_PROCESSING = 1 + ROGUE_TOURN_LAYER_STATUS_FINISH = 2 + + +class RogueTournRoomStatus(betterproto.Enum): + ROGUE_TOURN_ROOM_STATUS_NONE = 0 + ROGUE_TOURN_ROOM_STATUS_INITED = 1 + ROGUE_TOURN_ROOM_STATUS_PROCESSING = 2 + ROGUE_TOURN_ROOM_STATUS_FINISH = 3 + + +class RogueTournSettleReason(betterproto.Enum): + ROGUE_TOURN_SETTLE_REASON_NONE = 0 + ROGUE_TOURN_SETTLE_REASON_WIN = 1 + ROGUE_TOURN_SETTLE_REASON_FAIL = 2 + ROGUE_TOURN_SETTLE_REASON_INTERRUPT = 3 + + +class RogueTournHandbookType(betterproto.Enum): + ROGUE_TOURN_HANDBOOK_NONE = 0 + ROGUE_TOURN_HANDBOOK_SIMPLE_MIRACLE = 1 + ROGUE_TOURN_HANDBOOK_HEX_MIRACLE = 2 + ROGUE_TOURN_HANDBOOK_BUFF = 3 + ROGUE_TOURN_HANDBOOK_EVENT = 4 + ROGUE_TOURN_HANDBOOK_FORMULA = 5 + ROGUE_TOURN_HANDBOOK_TITAN_BLESS = 6 + +class SkillExtraTag(betterproto.Enum): + SCENE_CAST_SKILL_NONE = 0 + SCENE_CAST_SKILL_PROJECTILE_HIT = 1 + SCENE_CAST_SKILL_PROJECTILE_LIFETIME_FINISH = 2 + + +class MonsterBattleType(betterproto.Enum): + MONSTER_BATTLE_TYPE_NONE = 0 + MONSTER_BATTLE_TYPE_TRIGGER_BATTLE = 1 + MONSTER_BATTLE_TYPE_DIRECT_DIE_SIMULATE_BATTLE = 2 + MONSTER_BATTLE_TYPE_DIRECT_DIE_SKIP_BATTLE = 3 + MONSTER_BATTLE_TYPE_NO_BATTLE = 4 + + +class SceneEntityBuffChangeType(betterproto.Enum): + SCENE_ENTITY_BUFF_CHANGE_TYPE_DEFAULT = 0 + SCENE_ENTITY_BUFF_CHANGE_TYPE_ADD_MAZEBUFF = 1 + SCENE_ENTITY_BUFF_CHANGE_TYPE_ADD_ADV_MODIFIER = 2 + + +class EnterSceneReason(betterproto.Enum): + ENTER_SCENE_REASON_NONE = 0 + ENTER_SCENE_REASON_CHALLENGE_TIMEOUT = 1 + ENTER_SCENE_REASON_ROGUE_TIMEOUT = 2 + ENTER_SCENE_REASON_CHANGE_STORYLINE = 3 + ENTER_SCENE_REASON_DIMENSION_MERGE = 4 + + +class ChestType(betterproto.Enum): + MAP_INFO_CHEST_TYPE_NONE = 0 + MAP_INFO_CHEST_TYPE_NORMAL = 101 + MAP_INFO_CHEST_TYPE_CHALLENGE = 102 + MAP_INFO_CHEST_TYPE_PUZZLE = 104 + + +class GameplayCounterUpdateReason(betterproto.Enum): + GAMEPLAY_COUNTER_UPDATE_REASON_NONE = 0 + GAMEPLAY_COUNTER_UPDATE_REASON_ACTIVATE = 1 + GAMEPLAY_COUNTER_UPDATE_REASON_DEACTIVATE = 2 + GAMEPLAY_COUNTER_UPDATE_REASON_CHANGE = 3 + + +class SceneGroupRefreshType(betterproto.Enum): + SCENE_GROUP_REFRESH_TYPE_NONE = 0 + SCENE_GROUP_REFRESH_TYPE_LOADED = 1 + SCENE_GROUP_REFRESH_TYPE_UNLOAD = 2 + +class ChangeStoryLineAction(betterproto.Enum): + ChangeStoryLineAction_None = 0 + ChangeStoryLineAction_FinishAction = 1 + ChangeStoryLineAction_Client = 2 + ChangeStoryLineAction_CustomOP = 3 + ChangeStoryLineAction_Raid = 4 + +class HandPropType(betterproto.Enum): + SWITCH_HAND_OP_PROP_TYPE_NONE = 0 + SWITCH_HAND_OP_PROP_TYPE_CATCH = 1 + SWITCH_HAND_OP_PROP_TYPE_LIFT = 2 + +class PKHJBPMIBBA(betterproto.Enum): + SWORD_TRAIN_GAME_SOURCE_TYPE_NONE = 0 + SWORD_TRAIN_GAME_SOURCE_TYPE_TURN_SETTLE = 1 + SWORD_TRAIN_GAME_SOURCE_TYPE_STATUS_UPGRADE = 2 + SWORD_TRAIN_GAME_SOURCE_TYPE_ACTION = 3 + SWORD_TRAIN_GAME_SOURCE_TYPE_ACTION_HINT = 4 + SWORD_TRAIN_GAME_SOURCE_TYPE_STORY = 5 + SWORD_TRAIN_GAME_SOURCE_TYPE_EXAM_BONUS = 6 + SWORD_TRAIN_GAME_SOURCE_TYPE_DIALOGUE = 7 + + +class BJNCDEFEEJI(betterproto.Enum): + SWORD_TRAINING_DAILY_PHASE_TYPE_NONE = 0 + SWORD_TRAINING_DAILY_PHASE_TYPE_MORNING = 1 + SWORD_TRAINING_DAILY_PHASE_TYPE_NOON = 2 + SWORD_TRAINING_DAILY_PHASE_TYPE_AFTERNOON = 3 + SWORD_TRAINING_DAILY_PHASE_TYPE_EVENING = 4 + + +class HDIJJMDPILE(betterproto.Enum): + SWORD_TRAINING_STATUS_TYPE_NONE = 0 + SWORD_TRAINING_STATUS_TYPE_POWER = 1 + SWORD_TRAINING_STATUS_TYPE_AGILITY = 2 + SWORD_TRAINING_STATUS_TYPE_TOUGHNESS = 3 + SWORD_TRAINING_STATUS_TYPE_PERCEPTION = 4 + _SWORD_TRAINING_STATUS_TYPE_MAX = 5 + + +class HDMKPHALALG(betterproto.Enum): + SWORD_TRAINING_GAME_SETTLE_NONE = 0 + SWORD_TRAINING_GAME_SETTLE_FINISH = 1 + SWORD_TRAINING_GAME_SETTLE_GIVE_UP = 2 + SWORD_TRAINING_GAME_SETTLE_BATTLE_FAILED = 3 + SWORD_TRAINING_GAME_SETTLE_FORCE = 4 + SWORD_TRAINING_GAME_SETTLE_BY_RESTORE = 5 + +class KNOOCOCANAM(betterproto.Enum): + BuildGoalStepNone = 0 + BuildGoalStepIdle = 1 + BuildGoalStepStart = 2 + BuildGoalStepFinish = 3 + + +class CBEJAJENOHJ(betterproto.Enum): + kTrainPartySrcNone = 0 + kTrainPartySrcCard = 1 + kTrainPartySrcGrid = 2 + kTrainPartySrcPam = 3 + kTrainPartySrcPassenger = 4 + kTrainPartySrcBuilding = 5 + + +class IJDNOJEMIAN(betterproto.Enum): + kDialogueEventNone = 0 + kGamePlayStartDialogueEvent = 1 + kGridDialogueEvent = 2 + kAfterMeetingDialogueEvent = 3 + + +class LCDEMGACEKD(betterproto.Enum): + kMtSkillNone = 0 + kMtSkillModifyBase = 1 + kMtSkillModifyRatio = 2 + kMtSkillMultiplyRatio = 3 + kMtSkillSelfDestroy = 4 + + +class DMLCPAKDBLJ(betterproto.Enum): + TRAIN_PARTY_MT_CATEGORY_NONE = 0 + TRAIN_PARTY_MT_CATEGORY_S = 1 + TRAIN_PARTY_MT_CATEGORY_A = 2 + TRAIN_PARTY_MT_CATEGORY_B = 3 + TRAIN_PARTY_MT_CATEGORY_C = 4 + TRAIN_PARTY_MT_CATEGORY_D = 5 + TRAIN_PARTY_MT_CATEGORY_E = 6 + TRAIN_PARTY_MT_CATEGORY_F = 7 + TRAIN_PARTY_MT_CATEGORY_G = 8 + +class TrainVisitorRewardSendType(betterproto.Enum): + TRAIN_VISITOR_REWARD_SEND_NONE = 0 + TRAIN_VISITOR_REWARD_SEND_REGISTER = 1 + TRAIN_VISITOR_REWARD_SEND_MISSION = 2 + + +class TrainVisitorStatus(betterproto.Enum): + TRAIN_VISITOR_STATUS_NONE = 0 + TRAIN_VISITOR_STATUS_INIT = 1 + TRAIN_VISITOR_STATUS_GET_ON = 2 + TRAIN_VISITOR_STATUS_GET_OFF = 3 + TRAIN_VISITOR_STATUS_BE_TRAIN_MEMBER = 4 + + +class TrainVisitorRegisterGetType(betterproto.Enum): + TRAIN_VISITOR_REGISTER_GET_TYPE_NONE = 0 + TRAIN_VISITOR_REGISTER_GET_TYPE_AUTO = 1 + TRAIN_VISITOR_REGISTER_GET_TYPE_MANUAL = 2 + +class HGKKPPLJBOI(betterproto.Enum): + PAGE_NONE = 0 + PAGE_UNLOCKED = 1 + PAGE_INTERACTED = 2 + + +class DCJAOPDINOI(betterproto.Enum): + PAGE_DESC_NONE = 0 + PAGE_DESC_SHOW_DETAIL = 1 + PAGE_DESC_COLLAPSE = 2 + +class IMKNBJCOIOP(betterproto.Enum): + TREASURE_DUNGEON_RECORD_NONE = 0 + TREASURE_DUNGEON_RECORD_ADD_HP = 1 + TREASURE_DUNGEON_RECORD_SUB_HP = 2 + TREASURE_DUNGEON_RECORD_SUB_HP_NO_EXPLORE = 3 + TREASURE_DUNGEON_RECORD_ADD_ATTACK = 5 + TREASURE_DUNGEON_RECORD_ADD_DEFENCE = 6 + TREASURE_DUNGEON_RECORD_ADD_EXPLORE = 9 + TREASURE_DUNGEON_RECORD_SUB_EXPLORE = 10 + TREASURE_DUNGEON_RECORD_ADD_EXPLORE_OVERFLOW = 11 + TREASURE_DUNGEON_RECORD_SUMMON = 15 + TREASURE_DUNGEON_RECORD_KILL = 16 + TREASURE_DUNGEON_RECORD_ADD_TRIAL_AVATAR = 20 + TREASURE_DUNGEON_RECORD_ADD_BUFF = 24 + TREASURE_DUNGEON_RECORD_UNLOCK_DOOR = 25 + TREASURE_DUNGEON_RECORD_ENEMY_ENHANCE = 27 + TREASURE_DUNGEON_RECORD_ENEMY_WEAKEN = 28 + TREASURE_DUNGEON_RECORD_ENEMY_AURA_REMOVE = 29 + TREASURE_DUNGEON_RECORD_SPECIAL_MONSTER_RUN = 30 + TREASURE_DUNGEON_RECORD_SPECIAL_MONSTER_KILL = 31 + TREASURE_DUNGEON_RECORD_BATTLE_BUFF_TRIGGER_SUCCESS = 33 + TREASURE_DUNGEON_RECORD_BATTLE_BUFF_TRIGGER_FAIL = 34 + TREASURE_DUNGEON_RECORD_BATTLE_BUFF_ADD_EXPLORE = 35 + TREASURE_DUNGEON_RECORD_BATTLE_BUFF_OPEN_GRID = 36 + TREASURE_DUNGEON_RECORD_BATTLE_BUFF_ADD_ITEM = 37 + TREASURE_DUNGEON_RECORD_AVATAR_DEAD = 40 + TREASURE_DUNGEON_RECORD_TRIAL_AVATAR_DEAD = 41 + TREASURE_DUNGEON_RECORD_ALL_AVATAR_DEAD = 42 + TREASURE_DUNGEON_RECORD_OPEN_ITEM_CHEST = 43 + +class TutorialStatus(betterproto.Enum): + TUTORIAL_NONE = 0 + TUTORIAL_UNLOCK = 1 + TUTORIAL_FINISH = 2 + +class MHHLJFEJGNM(betterproto.Enum): + WAYPOINT_TYPE_NONE = 0 + WAYPOINT_TYPE_STAGE = 1 + WAYPOINT_TYPE_PLOT = 2 + + +class OBFAICFOGMP(betterproto.Enum): + WAYPOINT_UNLOCK_NONE = 0 + WAYPOINT_UNLOCK_PRE = 1 + WAYPOINT_UNLOCK_LEVEL = 2 + +class DJEBIMHNPBM(betterproto.Enum): + DISPATCH_TYPE_NONE = 0 + DISPATCH_TYPE_BY_ADDR = 1 + DISPATCH_TYPE_BY_MOD = 2 + DISPATCH_TYPE_BY_RAND = 3 + DISPATCH_TYPE_BY_CHASH = 4 + DISPATCH_TYPE_BY_STICKY_SESSION = 5 + DISPATCH_TYPE_BY_OBJECT = 6 + + +class PlayerKickOutScNotifyKickType(betterproto.Enum): + KICK_SQUEEZED = 0 + KICK_BLACK = 1 + KICK_CHANGE_PWD = 2 + KICK_LOGIN_WHITE_TIMEOUT = 3 + KICK_ACE_ANTI_CHEATER = 4 + KICK_BY_GM = 5 + + +class OIOPBDBJHIEIPKPKDCEBKI(betterproto.Enum): + NotReach = 0 + Received = 1 + CanReceive = 2 + + +@dataclass +class MMMNFDNLJMD(betterproto.Message): + marble_game_begin: int = betterproto.int32_field(101) + marble_game_end: int = betterproto.int32_field(102) + marble_game_round: int = betterproto.int32_field(103) + marble_game_turn: int = betterproto.int32_field(104) + queue_position: int = betterproto.uint32_field(1) + g_p_j_g_g_k_n_o_a_f_d: int = betterproto.uint32_field(2) + + +@dataclass +class HCJJOOFKCJH(betterproto.Message): + lpdbpkkadgg: int = betterproto.uint32_field(1) + homgcfjpblk: int = betterproto.int32_field(2) + cjjblmkjapa: int = betterproto.int32_field(3) + + +@dataclass +class LNGMDMIPCKL(betterproto.Message): + lpdbpkkadgg: int = betterproto.uint32_field(1) + jojahiafnlk: int = betterproto.uint32_field(2) + + +@dataclass +class CCCNHOECCMD(betterproto.Message): + item_id: int = betterproto.uint32_field(1) + banelelnlkb: int = betterproto.uint32_field(2) + skill_id: int = betterproto.uint32_field(3) + display_value: int = betterproto.int32_field(4) + + +@dataclass +class NOOBBIHJKMA(betterproto.Message): + mflekhhpieo: int = betterproto.int32_field(1) + majlgjcfgja: int = betterproto.int32_field(2) + iolcflofagf: int = betterproto.int32_field(3) + ameiimfkbfa: int = betterproto.int32_field(4) + + +@dataclass +class LJNPGKDOJHO(betterproto.Message): + monster_battle_type: int = betterproto.uint32_field(1) + dbadlnfopao: int = betterproto.uint64_field(2) + level_id: int = betterproto.uint32_field(3) + nlibkabfgcc: int = betterproto.uint32_field(4) + biecgfimcfb: List["HCJJOOFKCJH"] = betterproto.message_field(5) + rank: int = betterproto.uint32_field(6) + ekldpalnldc: int = betterproto.uint64_field(7) + fffgfcphbpn: List["HCJJOOFKCJH"] = betterproto.message_field(8) + jblmgnpmadm: int = betterproto.uint32_field(9) + + +@dataclass +class BPNMJCHEDNL(betterproto.Message): + monster_battle_type: int = betterproto.uint32_field(1) + dbadlnfopao: int = betterproto.uint64_field(2) + level_id: int = betterproto.uint32_field(3) + nlibkabfgcc: int = betterproto.uint32_field(4) + biecgfimcfb: List["HCJJOOFKCJH"] = betterproto.message_field(5) + rank: int = betterproto.uint32_field(6) + ekldpalnldc: int = betterproto.uint64_field(7) + fffgfcphbpn: List["HCJJOOFKCJH"] = betterproto.message_field(8) + jblmgnpmadm: int = betterproto.uint32_field(9) + imbclfcbodj: int = betterproto.uint32_field(10) + score_id: int = betterproto.int32_field(11) + npjeecedpok: int = betterproto.int32_field(12) + pceaecmkdeh: List["LNGMDMIPCKL"] = betterproto.message_field(13) + ifnmbngifph: int = betterproto.uint32_field(14) + iehjgombpbi: int = betterproto.uint32_field(15) + iphafkfgnao: int = betterproto.uint32_field(16) + lbpfeclgefc: int = betterproto.uint32_field(17) + + +@dataclass +class FOOPINGAFEG(betterproto.Message): + monster_battle_type: int = betterproto.uint32_field(1) + dbadlnfopao: int = betterproto.uint64_field(2) + level_id: int = betterproto.uint32_field(3) + nlibkabfgcc: int = betterproto.uint32_field(4) + ighlabggije: int = betterproto.uint32_field(5) + lpdbpkkadgg: int = betterproto.uint32_field(6) + hgbbkgnepfb: bool = betterproto.bool_field(7) + feopfholkbm: List["HCJJOOFKCJH"] = betterproto.message_field(8) + rank: int = betterproto.uint32_field(9) + cndckakkmcg: List["HCJJOOFKCJH"] = betterproto.message_field(10) + jblmgnpmadm: int = betterproto.uint32_field(11) + skill_info: List["CCCNHOECCMD"] = betterproto.message_field(12) + kbgajgeomgl: List["NOOBBIHJKMA"] = betterproto.message_field(13) + lelhcfoeoco: List["HCJJOOFKCJH"] = betterproto.message_field(14) + imjekfdhing: List["HCJJOOFKCJH"] = betterproto.message_field(15) + djnmhmpkkkb: int = betterproto.uint32_field(16) + + +@dataclass +class OFILKJCLEGI(betterproto.Message): + monster_battle_type: int = betterproto.uint32_field(1) + dbadlnfopao: int = betterproto.uint64_field(2) + level_id: int = betterproto.uint32_field(3) + nlibkabfgcc: int = betterproto.uint32_field(4) + nleaijhapap: bool = betterproto.bool_field(5) + ighlabggije: int = betterproto.uint32_field(6) + rank: int = betterproto.uint32_field(7) + ekldpalnldc: int = betterproto.uint64_field(8) + jblmgnpmadm: int = betterproto.uint32_field(9) + cboiiacbakf: int = betterproto.uint32_field(10) + buff_list: List[int] = betterproto.uint32_field(11) + djnmhmpkkkb: int = betterproto.uint32_field(12) + + +@dataclass +class PlayerBasicInfo(betterproto.Message): + nickname: str = betterproto.string_field(1) + level: int = betterproto.uint32_field(2) + exp: int = betterproto.uint32_field(3) + stamina: int = betterproto.uint32_field(4) + mcoin: int = betterproto.uint32_field(5) + hcoin: int = betterproto.uint32_field(6) + scoin: int = betterproto.uint32_field(7) + world_level: int = betterproto.uint32_field(8) + + +@dataclass +class SpBarInfo(betterproto.Message): + cur_sp: int = betterproto.uint32_field(1) + max_sp: int = betterproto.uint32_field(2) + + +@dataclass +class BlackInfo(betterproto.Message): + begin_time: int = betterproto.int64_field(1) + end_time: int = betterproto.int64_field(2) + limit_level: int = betterproto.uint32_field(3) + ban_type: int = betterproto.uint32_field(4) + + +@dataclass +class FeverTimeAvatar(betterproto.Message): + avatar_type: "AvatarType" = betterproto.enum_field(1) + id: int = betterproto.uint32_field(2) + + +@dataclass +class OILPIACENNH(betterproto.Message): + avatar_type: "AvatarType" = betterproto.enum_field(1) + id: int = betterproto.uint32_field(2) + level: int = betterproto.uint32_field(3) + index: int = betterproto.uint32_field(4) + ggdiibcdobb: int = betterproto.uint32_field(5) + + +@dataclass +class VersionCount(betterproto.Message): + version: int = betterproto.uint32_field(1) + count: int = betterproto.uint32_field(2) + + +@dataclass +class ClientDownloadData(betterproto.Message): + version: int = betterproto.uint32_field(1) + time: int = betterproto.int64_field(2) + data: bytes = betterproto.bytes_field(3) + haehhcpoapp: int = betterproto.uint32_field(4) + + +@dataclass +class ClientObjDownloadData(betterproto.Message): + bidjpeimllf: bytes = betterproto.bytes_field(1) + client_obj_download_data: "ClientDownloadData" = betterproto.message_field(2) + jedhnejhgnp: List["ClientDownloadData"] = betterproto.message_field(3) + + +@dataclass +class ClientUploadData(betterproto.Message): + tag: str = betterproto.string_field(1) + value: str = betterproto.string_field(2) + + +@dataclass +class FeatureSwitchParam(betterproto.Message): + switch_list: List[int] = betterproto.uint32_field(1) + + +@dataclass +class FeatureSwitchInfo(betterproto.Message): + type: "FeatureSwitchType" = betterproto.enum_field(1) + switch_list: List["FeatureSwitchParam"] = betterproto.message_field(2) + is_all_closed: bool = betterproto.bool_field(3) + + +@dataclass +class JGFKICDCFLJ(betterproto.Message): + fdkgfdicmfd: str = betterproto.string_field(1) + mdjcaoagcko: str = betterproto.string_field(2) + gioohoomjho: str = betterproto.string_field(3) + fbmllnkcfen: str = betterproto.string_field(4) + dgoohibaoee: str = betterproto.string_field(5) + fkbamboodkj: str = betterproto.string_field(6) + mac: str = betterproto.string_field(7) + + +@dataclass +class OCCHNEFHGNE(betterproto.Message): + ejieagflged: int = betterproto.int32_field(28) + ldbfaikmifi: int = betterproto.int32_field(29) + pkflgkphoed: int = betterproto.int32_field(30) + akdclaepfej: int = betterproto.int32_field(31) + + +@dataclass +class ReplayInfo(betterproto.Message): + dknpkjmahcm: int = betterproto.uint64_field(1) + replay_type: "ReplayType" = betterproto.enum_field(2) + stage_id: int = betterproto.uint32_field(3) + uid: int = betterproto.uint32_field(4) + nickname: str = betterproto.string_field(5) + head_icon: int = betterproto.uint32_field(6) + replay_name: str = betterproto.string_field(7) + create_time: int = betterproto.uint64_field(8) + afehlmfibmd: int = betterproto.uint32_field(9) + cmpbkbbkaoa: int = betterproto.uint32_field(10) + + +@dataclass +class PunkLordBattleAvatar(betterproto.Message): + avatar_id: int = betterproto.uint32_field(1) + avatar_level: int = betterproto.uint32_field(2) + + +@dataclass +class PunkLordBattleRecord(betterproto.Message): + uid: int = betterproto.uint32_field(1) + damage_hp: int = betterproto.uint32_field(2) + is_final_hit: bool = betterproto.bool_field(3) + over_kill_damage_hp: int = betterproto.uint32_field(4) + battle_replay_key: str = betterproto.string_field(5) + avatar_list: List["PunkLordBattleAvatar"] = betterproto.message_field(6) + assist_score: int = betterproto.uint32_field(7) + damage_score: int = betterproto.uint32_field(8) + final_hit_score: int = betterproto.uint32_field(9) + + +@dataclass +class PunkLordBattleRecordList(betterproto.Message): + battle_record_list: List["PunkLordBattleRecord"] = betterproto.message_field(1) + + +@dataclass +class PunkLordMonsterKey(betterproto.Message): + uid: int = betterproto.uint32_field(1) + monster_id: int = betterproto.uint32_field(2) + + +@dataclass +class PunkLordMonsterBasicInfo(betterproto.Message): + uid: int = betterproto.uint32_field(1) + monster_id: int = betterproto.uint32_field(2) + config_id: int = betterproto.uint32_field(3) + world_level: int = betterproto.uint32_field(4) + create_time: int = betterproto.int64_field(5) + left_hp: int = betterproto.uint32_field(6) + attacker_num: int = betterproto.uint32_field(7) + share_type: "PunkLordShareType" = betterproto.enum_field(8) + ppboceckcah: bool = betterproto.bool_field(9) + + +@dataclass +class PunkLordBattleReplay(betterproto.Message): + battle_replay_key: str = betterproto.string_field(1) + replay_info: "ReplayInfo" = betterproto.message_field(2) + + +@dataclass +class ILDHFMHBKNC(betterproto.Message): + infhikbljla: int = betterproto.uint64_field(1) + nbdlpgbidlc: int = betterproto.uint32_field(2) + ahbemdlggeo: int = betterproto.uint32_field(3) + + +@dataclass +class LKAPFHAHNEM(betterproto.Message): + panel_id: int = betterproto.uint32_field(1) + modifier_content_type: int = betterproto.uint32_field(2) + cfdanmomhpi: int = betterproto.uint64_field(3) + + +@dataclass +class PEDLPHDBNAF(betterproto.Message): + lfcphajcekf: "ILDHFMHBKNC" = betterproto.message_field(101) + celmkolbjnn: "LKAPFHAHNEM" = betterproto.message_field(102) + + +@dataclass +class RegionInfo(betterproto.Message): + name: str = betterproto.string_field(1) + title: str = betterproto.string_field(2) + dispatch_url: str = betterproto.string_field(3) + env_type: str = betterproto.string_field(4) + display_name: str = betterproto.string_field(5) + msg: str = betterproto.string_field(6) + + +@dataclass +class Dispatch(betterproto.Message): + retcode: int = betterproto.uint32_field(1) + msg: str = betterproto.string_field(2) + top_sever_region_name: str = betterproto.string_field(3) + region_list: List["RegionInfo"] = betterproto.message_field(4) + stop_desc: str = betterproto.string_field(5) + + +@dataclass +class RelicFilterPlanSettings(betterproto.Message): + rarity_bitset: int = betterproto.uint32_field(1) + relic_set_list: List[int] = betterproto.uint32_field(2) + body_main_property_list: List[int] = betterproto.uint32_field(3) + foot_main_property_list: List[int] = betterproto.uint32_field(4) + sphere_main_property_list: List[int] = betterproto.uint32_field(5) + rope_main_property_list: List[int] = betterproto.uint32_field(6) + is_include_filter_sub_property: bool = betterproto.bool_field(7) + sub_property_num: int = betterproto.uint32_field(8) + sub_property_list: List[int] = betterproto.uint32_field(9) + head_main_property_list: List[int] = betterproto.uint32_field(10) + hand_main_property_list: List[int] = betterproto.uint32_field(11) + + +@dataclass +class BattleOp(betterproto.Message): + turn_counter: int = betterproto.uint32_field(1) + state: int = betterproto.uint32_field(2) + action_entity_id: int = betterproto.uint32_field(3) + target_entity_id: int = betterproto.uint32_field(4) + op_type: int = betterproto.uint32_field(5) + skill_index: int = betterproto.uint32_field(6) + operation_counter: int = betterproto.uint32_field(7) + nplieiphcbf: str = betterproto.string_field(8) + + +@dataclass +class BattleEquipment(betterproto.Message): + id: int = betterproto.uint32_field(1) + level: int = betterproto.uint32_field(2) + promotion: int = betterproto.uint32_field(3) + rank: int = betterproto.uint32_field(4) + + +@dataclass +class BattleRelic(betterproto.Message): + id: int = betterproto.uint32_field(1) + level: int = betterproto.uint32_field(2) + main_affix_id: int = betterproto.uint32_field(3) + sub_affix_list: List["RelicAffix"] = betterproto.message_field(4) + unique_id: int = betterproto.uint32_field(5) + set_id: int = betterproto.uint32_field(6) + type: int = betterproto.uint32_field(7) + rarity: int = betterproto.uint32_field(8) + + +@dataclass +class AvatarSkillTree(betterproto.Message): + point_id: int = betterproto.uint32_field(1) + level: int = betterproto.uint32_field(2) + + +@dataclass +class RelicAffix(betterproto.Message): + affix_id: int = betterproto.uint32_field(1) + cnt: int = betterproto.uint32_field(2) + step: int = betterproto.uint32_field(3) + + +@dataclass +class BJHEBCCBANA(betterproto.Message): + ljpadncgloc: bool = betterproto.bool_field(1) + dddhnaklmhf: List[int] = betterproto.uint32_field(2) + jgjcdmjimnn: int = betterproto.uint32_field(3) + pofmkdabehd: int = betterproto.uint32_field(4) + + +@dataclass +class BattleAvatar(betterproto.Message): + avatar_type: "AvatarType" = betterproto.enum_field(1) + id: int = betterproto.uint32_field(2) + level: int = betterproto.uint32_field(3) + rank: int = betterproto.uint32_field(4) + index: int = betterproto.uint32_field(5) + skilltree_list: List["AvatarSkillTree"] = betterproto.message_field(6) + equipment_list: List["BattleEquipment"] = betterproto.message_field(7) + hp: int = betterproto.uint32_field(8) + promotion: int = betterproto.uint32_field(10) + relic_list: List["BattleRelic"] = betterproto.message_field(11) + world_level: int = betterproto.uint32_field(12) + assist_uid: int = betterproto.uint32_field(13) + ecifjlakhcl: "BJHEBCCBANA" = betterproto.message_field(15) + sp_bar: "SpBarInfo" = betterproto.message_field(16) + gmobaocefce: int = betterproto.uint32_field(17) + imjjkbjoohj: List["AvatarSkillTree"] = betterproto.message_field(18) + + +@dataclass +class BattleMonsterParam(betterproto.Message): + hard_level_group: int = betterproto.uint32_field(1) + level: int = betterproto.uint32_field(2) + elite_group: int = betterproto.uint32_field(3) + dneampllfme: int = betterproto.uint32_field(4) + + +@dataclass +class BattleMonster(betterproto.Message): + monster_id: int = betterproto.uint32_field(1) + cur_hp: int = betterproto.uint32_field(2) + max_hp: int = betterproto.uint32_field(3) + + +@dataclass +class BattleMonsterWave(betterproto.Message): + monster_list: List["BattleMonster"] = betterproto.message_field(1) + monster_param: "BattleMonsterParam" = betterproto.message_field(2) + battle_stage_id: int = betterproto.uint32_field(3) + battle_wave_id: int = betterproto.uint32_field(4) + + +@dataclass +class BattleBuff(betterproto.Message): + id: int = betterproto.uint32_field(1) + level: int = betterproto.uint32_field(2) + owner_index: int = betterproto.uint32_field(3) + wave_flag: int = betterproto.uint32_field(4) + target_index_list: List[int] = betterproto.uint32_field(5) + dynamic_values: Dict[str, float] = betterproto.map_field( + 6, betterproto.TYPE_STRING, betterproto.TYPE_FLOAT + ) + + +@dataclass +class ILLCDMOCLDO(betterproto.Message): + id: int = betterproto.uint32_field(1) + hfaljihkecn: int = betterproto.uint32_field(2) + laejdghmkdb: int = betterproto.uint32_field(3) + + +@dataclass +class LJGIAGLFHHC(betterproto.Message): + fenmmmkoocf: int = betterproto.uint32_field(1) + + +@dataclass +class ENFLFBDAOIJ(betterproto.Message): + id: int = betterproto.uint32_field(1) + hfaljihkecn: int = betterproto.uint32_field(2) + + +@dataclass +class GMGJCIHDFMA(betterproto.Message): + id: int = betterproto.uint32_field(1) + progress: int = betterproto.uint32_field(2) + + +@dataclass +class BattleTarget(betterproto.Message): + id: int = betterproto.uint32_field(1) + progress: int = betterproto.uint32_field(2) + total_progress: int = betterproto.uint32_field(3) + + +@dataclass +class BattleTargetList(betterproto.Message): + battle_target_list: List["BattleTarget"] = betterproto.message_field(1) + + +@dataclass +class BattleLineup(betterproto.Message): + avatar_list: List["BattleAvatar"] = betterproto.message_field(1) + monster_wave_list: List["BattleMonsterWave"] = betterproto.message_field(2) + buff_list: List["BattleBuff"] = betterproto.message_field(3) + world_level: int = betterproto.uint32_field(7) + battle_target_info: Dict[int, "BattleTargetList"] = betterproto.map_field( + 9, betterproto.TYPE_UINT32, betterproto.TYPE_MESSAGE + ) + ajgpjglpmio: "LJGIAGLFHHC" = betterproto.message_field(10) + ejcljldendm: List["BattleAvatar"] = betterproto.message_field(11) + jpgifchjdlk: "EvolveBuildBattleInfo" = betterproto.message_field(12) + mfkjokajjmj: "GIEIBEACBAO" = betterproto.message_field(13) + battle_rogue_magic_info: "BattleRogueMagicInfo" = betterproto.message_field(14) + + +@dataclass +class GIEIBEACBAO(betterproto.Message): + gccjdhkhmnk: Dict[int, int] = betterproto.map_field( + 1, betterproto.TYPE_UINT32, betterproto.TYPE_UINT32 + ) + fpbnipmhanh: int = betterproto.uint32_field(2) + aagiancieeg: int = betterproto.uint32_field(3) + elpfomlcobm: int = betterproto.uint32_field(4) + + +@dataclass +class AetherAvatarInfo(betterproto.Message): + id: int = betterproto.uint32_field(1) + index: int = betterproto.uint32_field(2) + promotion: int = betterproto.uint32_field(3) + passive_skill: List[int] = betterproto.uint32_field(4) + spirit_lineup_type: "AetherdivideSpiritLineupType" = betterproto.enum_field(5) + sp_bar: "SpBarInfo" = betterproto.message_field(6) + + +@dataclass +class PNDFMBJFGIM(betterproto.Message): + avatar_list: List["AetherAvatarInfo"] = betterproto.message_field(1) + monster_wave_list: List["BattleMonsterWave"] = betterproto.message_field(2) + buff_list: List["BattleBuff"] = betterproto.message_field(3) + + +@dataclass +class ClientTurnSnapshot(betterproto.Message): + turn_counter: int = betterproto.uint32_field(1) + random_counter: int = betterproto.uint32_field(2) + anim_event_counter: int = betterproto.uint32_field(3) + snapshot_list: List["CharacterSnapshot"] = betterproto.message_field(4) + anim_event_list: List["AnimEventSnapshot"] = betterproto.message_field(5) + jeinbmlfcbp: int = betterproto.uint32_field(6) + + +@dataclass +class GamecoreConfig(betterproto.Message): + is_skip_verify: bool = betterproto.bool_field(1) + max_turn_cnt: int = betterproto.uint32_field(2) + is_auto_fight: bool = betterproto.bool_field(3) + csv_path: str = betterproto.string_field(4) + lkfdpdldmib: bool = betterproto.bool_field(5) + mnalpnfnmio: bool = betterproto.bool_field(6) + ggfcojflkbp: int = betterproto.uint32_field(7) + + +@dataclass +class BattleBuffMsg(betterproto.Message): + buff_id_list: List[int] = betterproto.uint32_field(1) + buff_index_list: List[int] = betterproto.uint32_field(2) + buff_level_list: List[int] = betterproto.uint32_field(3) + buff_flag_list: List[int] = betterproto.uint32_field(4) + + +@dataclass +class DKFLALJDIFL(betterproto.Message): + mbbchgenggl: int = betterproto.uint32_field(1) + hfcdphchfgk: int = betterproto.uint32_field(2) + + +@dataclass +class MBMCFOLIOLO(betterproto.Message): + cdnojcacelj: bool = betterproto.bool_field(1) + haneginlani: Dict[str, "DKFLALJDIFL"] = betterproto.map_field( + 2, betterproto.TYPE_STRING, betterproto.TYPE_MESSAGE + ) + cjkmgenojbe: bytes = betterproto.bytes_field(3) + + +@dataclass +class MIAIDAILDKM(betterproto.Message): + eeflghcobml: List["ClientTurnSnapshot"] = betterproto.message_field(1) + kgbhehhfmpi: str = betterproto.string_field(2) + debug_extra_info: str = betterproto.string_field(3) + hlagimenbjg: List["BattleReplayStringHash"] = betterproto.message_field(4) + plane_id: int = betterproto.uint32_field(5) + floor_id: int = betterproto.uint32_field(6) + ebhlfaeglcd: int = betterproto.uint32_field(7) + bnjmmlkofcp: int = betterproto.uint32_field(8) + edhbgdeicnc: "MBMCFOLIOLO" = betterproto.message_field(9) + bbnaefbaplg: int = betterproto.uint32_field(10) + + +@dataclass +class BattleReplay(betterproto.Message): + version: int = betterproto.uint32_field(1) + logic_random_seed: int = betterproto.uint32_field(2) + stage_id: int = betterproto.uint32_field(3) + lineup: "BattleLineup" = betterproto.message_field(4) + op_list: List["BattleOp"] = betterproto.message_field(5) + turn_snapshot_hash: bytes = betterproto.bytes_field(6) + maze_plane_id: int = betterproto.uint32_field(7) + extra_ability_list: List[int] = betterproto.uint32_field(8) + is_ai_consider_ultra_skill: bool = betterproto.bool_field(9) + check_strategy: "BattleCheckStrategyType" = betterproto.enum_field(10) + battle_module_type: "BattleModuleType" = betterproto.enum_field(11) + battle_event: List["BattleEventBattleInfo"] = betterproto.message_field(12) + rounds_limit: int = betterproto.uint32_field(14) + config: "GamecoreConfig" = betterproto.message_field(15) + game_core_log_encode: bytes = betterproto.bytes_field(16) + client_version: int = betterproto.uint32_field(17) + ddogjokeccl: int = betterproto.uint32_field(18) + gmpcfgedhki: "PNDFMBJFGIM" = betterproto.message_field(19) + bnmiiahadjh: "MIAIDAILDKM" = betterproto.message_field(100) + + +@dataclass +class BattleReplayStringHash(betterproto.Message): + hash: int = betterproto.int32_field(1) + value: str = betterproto.string_field(2) + + +@dataclass +class AvatarProperty(betterproto.Message): + max_hp: float = betterproto.double_field(1) + attack: float = betterproto.double_field(2) + defence: float = betterproto.double_field(3) + speed: float = betterproto.double_field(4) + left_hp: float = betterproto.double_field(5) + left_sp: float = betterproto.double_field(6) + max_sp: float = betterproto.double_field(7) + + +@dataclass +class EquipmentProperty(betterproto.Message): + id: int = betterproto.uint32_field(1) + rank: int = betterproto.uint32_field(2) + promotion: int = betterproto.uint32_field(3) + level: int = betterproto.uint32_field(4) + + +@dataclass +class AttackDamageProperty(betterproto.Message): + attack_type: str = betterproto.string_field(1) + damage: float = betterproto.double_field(2) + + +@dataclass +class SkillUseProperty(betterproto.Message): + skill_id: int = betterproto.uint32_field(1) + skill_type: str = betterproto.string_field(2) + skill_level: int = betterproto.uint32_field(3) + skill_use_count: int = betterproto.uint32_field(4) + ifejkalhopi: int = betterproto.uint32_field(5) + jhdhlcncdnc: int = betterproto.uint32_field(6) + hoafnnijoom: int = betterproto.uint32_field(7) + mdeadclnjcj: int = betterproto.uint32_field(8) + ohnppjemkde: int = betterproto.uint32_field(9) + + +@dataclass +class GAAGEHABINM(betterproto.Message): + skill_id: int = betterproto.uint32_field(1) + hgflpenkiii: float = betterproto.double_field(2) + battle_target_list: List[int] = betterproto.uint32_field(3) + damage: float = betterproto.double_field(4) + + +@dataclass +class SpAddSource(betterproto.Message): + source: str = betterproto.string_field(1) + sp_add: int = betterproto.uint32_field(2) + + +@dataclass +class AbilityUseStt(betterproto.Message): + fkhhobbfmeh: str = betterproto.string_field(1) + count: int = betterproto.uint32_field(2) + total_damage: float = betterproto.double_field(3) + + +@dataclass +class AvatarBattleInfo(betterproto.Message): + avatar_type: "AvatarType" = betterproto.enum_field(1) + id: int = betterproto.uint32_field(2) + avatar_level: int = betterproto.uint32_field(3) + avatar_rank: int = betterproto.uint32_field(4) + avatar_promotion: int = betterproto.uint32_field(5) + avatar_status: "AvatarProperty" = betterproto.message_field(6) + avatar_skill: List["AvatarSkillTree"] = betterproto.message_field(7) + avatar_equipment: List["EquipmentProperty"] = betterproto.message_field(8) + total_turns: int = betterproto.uint32_field(9) + total_damage: float = betterproto.double_field(10) + total_heal: float = betterproto.double_field(11) + total_damage_taken: float = betterproto.double_field(12) + total_hp_recover: float = betterproto.double_field(13) + total_sp_cost: float = betterproto.double_field(14) + stage_id: int = betterproto.uint32_field(15) + stage_type: int = betterproto.uint32_field(16) + total_break_damage: float = betterproto.double_field(17) + attack_type_damage: List["AttackDamageProperty"] = betterproto.message_field(18) + attack_type_break_damage: List["AttackDamageProperty"] = betterproto.message_field( + 19 + ) + attack_type_max_damage: List["AttackDamageProperty"] = betterproto.message_field(20) + skill_times: List["SkillUseProperty"] = betterproto.message_field(21) + delay_cumulate: float = betterproto.double_field(22) + total_sp_add: int = betterproto.uint32_field(23) + sp_add_source: List["SpAddSource"] = betterproto.message_field(24) + total_bp_cost: int = betterproto.uint32_field(25) + die_times: int = betterproto.uint32_field(26) + revive_times: int = betterproto.uint32_field(27) + break_times: int = betterproto.uint32_field(28) + extra_turns: int = betterproto.uint32_field(29) + total_shield: float = betterproto.double_field(30) + total_shield_taken: float = betterproto.double_field(31) + total_shield_damage: float = betterproto.double_field(32) + initial_status: "AvatarProperty" = betterproto.message_field(33) + relics: List["BattleRelic"] = betterproto.message_field(34) + assist_uid: int = betterproto.uint32_field(35) + aadgflpbpdf: List["AttackDamageProperty"] = betterproto.message_field(36) + fpfbmimbbhj: float = betterproto.double_field(37) + ggpjohnocpc: float = betterproto.double_field(38) + lackcjhhimk: float = betterproto.double_field(39) + fmodlgobnpe: float = betterproto.double_field(40) + lhkabnickjn: List["AbilityUseStt"] = betterproto.message_field(41) + ncjhdjjdjnl: int = betterproto.uint32_field(42) + lkmgdiadopb: int = betterproto.uint32_field(43) + iblgmcipckm: float = betterproto.double_field(44) + hacjdjigmgp: float = betterproto.double_field(45) + imdjahajgcf: float = betterproto.double_field(46) + jdolkdbiclj: float = betterproto.double_field(47) + caccoddcjhi: float = betterproto.double_field(48) + lldmlohbflo: int = betterproto.uint32_field(49) + chnikkcibeg: int = betterproto.uint32_field(50) + lbnjhhhlpmo: int = betterproto.uint32_field(51) + pdlilfichil: float = betterproto.double_field(52) + pmklphjiohc: int = betterproto.uint32_field(53) + mpfaenekfdc: int = betterproto.uint32_field(54) + + +@dataclass +class MonsterProperty(betterproto.Message): + max_hp: float = betterproto.double_field(1) + attack: float = betterproto.double_field(2) + defence: float = betterproto.double_field(3) + shield: float = betterproto.double_field(4) + speed: float = betterproto.double_field(5) + left_hp: float = betterproto.double_field(6) + enter_battle_hp: float = betterproto.double_field(7) + + +@dataclass +class MonsterPhaseStt(betterproto.Message): + ndbojandnjn: int = betterproto.uint32_field(1) + mmcphlpecdj: float = betterproto.double_field(2) + doiadgdbohf: int = betterproto.uint32_field(3) + break_times: int = betterproto.uint32_field(4) + + +@dataclass +class MonsterBattleInfo(betterproto.Message): + entity_id: int = betterproto.uint32_field(1) + monster_id: int = betterproto.uint32_field(2) + oakilfgdacj: int = betterproto.uint32_field(3) + bfpaoanbjon: int = betterproto.uint32_field(4) + nkcmcmhafaf: "MonsterProperty" = betterproto.message_field(5) + total_turns: int = betterproto.uint32_field(6) + total_damage: float = betterproto.double_field(7) + total_heal: float = betterproto.double_field(8) + total_damage_taken: float = betterproto.double_field(9) + akgfcpfaolp: float = betterproto.double_field(10) + total_hp_recover: float = betterproto.double_field(11) + stage_id: int = betterproto.uint32_field(12) + battle_id: int = betterproto.uint32_field(13) + jbcdlfjjjdg: int = betterproto.uint32_field(14) + attack_type_damage: List["AttackDamageProperty"] = betterproto.message_field(15) + skill_times: List["SkillUseProperty"] = betterproto.message_field(16) + stage_type: int = betterproto.uint32_field(17) + acofippjkbi: float = betterproto.double_field(18) + delay_cumulate: float = betterproto.double_field(19) + fiedknkiebh: "DeathSource" = betterproto.enum_field(20) + wave: int = betterproto.uint32_field(21) + jhaogjjdbhl: int = betterproto.int32_field(22) + phase: int = betterproto.uint32_field(23) + dcmohecbolk: int = betterproto.uint32_field(24) + jedahlgbiem: "BattleTag" = betterproto.enum_field(25) + skill_info: List["GAAGEHABINM"] = betterproto.message_field(26) + lanfclolbof: int = betterproto.uint32_field(27) + kfgjbiljgdp: List["MonsterPhaseStt"] = betterproto.message_field(28) + fpkoniklica: int = betterproto.uint32_field(29) + jeemgaeifae: int = betterproto.uint32_field(30) + hbofdajjjme: "HEMBNDJAFDA" = betterproto.enum_field(31) + + +@dataclass +class BattleEventProperty(betterproto.Message): + sp_bar: "SpBarInfo" = betterproto.message_field(2) + + +@dataclass +class BattleEventBattleInfo(betterproto.Message): + battle_event_id: int = betterproto.uint32_field(1) + status: "BattleEventProperty" = betterproto.message_field(2) + skill_info: List["GAAGEHABINM"] = betterproto.message_field(3) + + +@dataclass +class ScoreInfo(betterproto.Message): + fjjdfpkgopc: int = betterproto.uint32_field(1) + score_id: int = betterproto.uint32_field(2) + + +@dataclass +class IBFFAJOHKMO(betterproto.Message): + avatar_id: int = betterproto.uint32_field(1) + leickpdifog: List[int] = betterproto.uint32_field(2) + source: int = betterproto.uint32_field(3) + damage: float = betterproto.double_field(4) + dikkhpfkapf: List[int] = betterproto.uint32_field(5) + eoofimegmfb: int = betterproto.int32_field(6) + bkjeampnank: float = betterproto.double_field(7) + blfhkgpmndk: int = betterproto.uint32_field(8) + wave: int = betterproto.uint32_field(9) + + +@dataclass +class KKMPKJPGGCL(betterproto.Message): + avatar_id: int = betterproto.uint32_field(1) + abapdfgjnme: int = betterproto.int32_field(2) + + +@dataclass +class CNPNNIJGLFI(betterproto.Message): + dpdnnmbcpoi: int = betterproto.uint32_field(1) + dbeljgbkbpa: int = betterproto.uint32_field(2) + entity_id: int = betterproto.uint32_field(3) + + +@dataclass +class IIIPHJIMNID(betterproto.Message): + ndbojandnjn: int = betterproto.uint32_field(1) + monster_id: int = betterproto.uint32_field(2) + nglpbhmlehn: List["KKMPKJPGGCL"] = betterproto.message_field(3) + hgflpenkiii: int = betterproto.uint32_field(4) + akkggpadaoo: List["CNPNNIJGLFI"] = betterproto.message_field(5) + + +@dataclass +class MMNDJAMEBML(betterproto.Message): + type: "BattleStaticticEventType" = betterproto.enum_field(1) + ocpppkddiml: int = betterproto.uint32_field(2) + display_value: int = betterproto.uint32_field(3) + + +@dataclass +class KPKKKJPJCPC(betterproto.Message): + lidgjndgbkm: int = betterproto.uint32_field(1) + oaabadfkcoa: int = betterproto.uint32_field(2) + + +@dataclass +class MEOIFIOAECF(betterproto.Message): + jjccjjinlfl: int = betterproto.uint32_field(1) + hemjhdoeebl: bool = betterproto.bool_field(2) + kacalgioedb: "KPKKKJPJCPC" = betterproto.message_field(3) + + +@dataclass +class EvolveBuildCardInfo(betterproto.Message): + card_id: int = betterproto.uint32_field(1) + param: float = betterproto.double_field(2) + is_enable: bool = betterproto.bool_field(3) + param_list: List[float] = betterproto.double_field(4) + + +@dataclass +class EvolveBuildGearDamageInfo(betterproto.Message): + gear_id: int = betterproto.uint32_field(1) + damage: float = betterproto.double_field(2) + hp_damage: float = betterproto.double_field(3) + + +@dataclass +class LGIFEDNKHON(betterproto.Message): + dakijnbfkob: List[int] = betterproto.uint32_field(1) + fjjobaemehp: List[int] = betterproto.uint32_field(2) + + +@dataclass +class MJKIBJLOBKD(betterproto.Message): + wave: int = betterproto.uint32_field(1) + score_id: int = betterproto.uint32_field(2) + dchiolbfkjn: int = betterproto.uint32_field(3) + bhjkmhmoeak: List["KPKKKJPJCPC"] = betterproto.message_field(4) + hgflpenkiii: float = betterproto.float_field(5) + + +@dataclass +class DKOOKEJCHGO(betterproto.Message): + chbjkkmiofd: int = betterproto.uint32_field(1) + hgflpenkiii: float = betterproto.double_field(2) + + +@dataclass +class PMNHMAMHGAI(betterproto.Message): + icphoomndka: int = betterproto.uint32_field(1) + enbjcpkgcol: List["MJKIBJLOBKD"] = betterproto.message_field(2) + oooglieooki: List["DKOOKEJCHGO"] = betterproto.message_field(3) + + +@dataclass +class EGDAJHJPLGI(betterproto.Message): + type: "BOJGAKMDPDL" = betterproto.enum_field(1) + count: int = betterproto.uint32_field(2) + + +@dataclass +class EvolveBuildBattleInfo(betterproto.Message): + cur_level_id: int = betterproto.uint32_field(1) + cur_period: int = betterproto.uint32_field(2) + cur_coin: int = betterproto.uint32_field(3) + weapon_slot_list: List["MEOIFIOAECF"] = betterproto.message_field(4) + accessory_slot_list: List["MEOIFIOAECF"] = betterproto.message_field(5) + ban_gear_list: List[int] = betterproto.uint32_field(6) + collection: "LGIFEDNKHON" = betterproto.message_field(7) + allowed_gear_list: List[int] = betterproto.uint32_field(8) + cur_exp: int = betterproto.uint32_field(9) + cur_reroll: int = betterproto.uint32_field(10) + cur_treasure_miss_cnt: int = betterproto.uint32_field(11) + period_id_list: List[int] = betterproto.uint32_field(12) + cur_gear_lost_cnt: int = betterproto.uint32_field(13) + cur_wave: int = betterproto.uint32_field(14) + is_unlock_gear_reroll: bool = betterproto.bool_field(15) + is_unlock_gear_ban: bool = betterproto.bool_field(16) + card_list: List["EvolveBuildCardInfo"] = betterproto.message_field(17) + gear_damage_list: List["EvolveBuildGearDamageInfo"] = betterproto.message_field(18) + stat_params: List[int] = betterproto.uint32_field(19) + is_giveup: bool = betterproto.bool_field(20) + cur_unused_round_cnt: int = betterproto.uint32_field(21) + stat_log_info: "PMNHMAMHGAI" = betterproto.message_field(22) + period_first_random_seed: int = betterproto.uint32_field(23) + cur_card_reroll: int = betterproto.uint32_field(24) + allowed_card_list: List[int] = betterproto.uint32_field(25) + func_list: List["EGDAJHJPLGI"] = betterproto.message_field(26) + finished_story_id: int = betterproto.uint32_field(27) + + +@dataclass +class PLPNLIBMNIO(betterproto.Message): + phase: str = betterproto.string_field(1) + dbdcnafoglf: float = betterproto.float_field(2) + hdalbiancmf: float = betterproto.float_field(3) + adjbbabehah: int = betterproto.uint32_field(4) + pjbiaejecae: int = betterproto.uint32_field(5) + kpnacghjalj: int = betterproto.uint32_field(6) + fpjadbgohkm: int = betterproto.uint32_field(7) + cjejofamdcd: int = betterproto.uint32_field(8) + bgjcedeahgm: List[int] = betterproto.uint32_field(9) + aagjcjiofpa: List[int] = betterproto.uint32_field(10) + + +@dataclass +class CHDONIGOKNM(betterproto.Message): + heocpakcelm: int = betterproto.uint32_field(1) + bghkbmfhmoj: int = betterproto.uint32_field(2) + loollagmnlh: int = betterproto.uint32_field(3) + hecjooobahc: int = betterproto.uint32_field(4) + fkeaaipkpaa: int = betterproto.uint32_field(5) + icleenhipoh: int = betterproto.uint32_field(6) + boss_info: List[int] = betterproto.uint32_field(7) + odbonkcmdmp: List["PLPNLIBMNIO"] = betterproto.message_field(8) + + +@dataclass +class JFFNDOBBNFB(betterproto.Message): + wave: int = betterproto.uint32_field(1) + hfihdddiljb: float = betterproto.double_field(2) + khgclcllecl: float = betterproto.double_field(3) + ffpmjfhncho: int = betterproto.uint32_field(4) + gmmbgamhbkb: int = betterproto.uint32_field(5) + + +@dataclass +class EKBAGMOMECL(betterproto.Message): + key: str = betterproto.string_field(1) + value: float = betterproto.double_field(2) + + +@dataclass +class BattleRogueMagicModifierInfo(betterproto.Message): + rogue_magic_battle_const: int = betterproto.uint32_field(1) + + +@dataclass +class BattleRogueMagicRoundCount(betterproto.Message): + battle_standard_round_limit: int = betterproto.uint32_field(1) + battle_extra_round_limit: int = betterproto.uint32_field(2) + + +@dataclass +class BattleRogueMagicUnit(betterproto.Message): + magic_unit_id: int = betterproto.uint32_field(1) + level: int = betterproto.uint32_field(2) + hemjhdoeebl: bool = betterproto.bool_field(3) + dice_slot_id: int = betterproto.uint32_field(4) + ikddalcbafj: Dict[int, int] = betterproto.map_field( + 5, betterproto.TYPE_UINT32, betterproto.TYPE_UINT32 + ) + + +@dataclass +class BattleRogueMagicScepter(betterproto.Message): + scepter_id: int = betterproto.uint32_field(1) + rogue_magic_unit_info_list: List["BattleRogueMagicUnit"] = ( + betterproto.message_field(2) + ) + level: int = betterproto.uint32_field(3) + trench_count: Dict[int, int] = betterproto.map_field( + 4, betterproto.TYPE_UINT32, betterproto.TYPE_UINT32 + ) + + +@dataclass +class BattleRogueMagicItemInfo(betterproto.Message): + battle_round_count: "BattleRogueMagicRoundCount" = betterproto.message_field(1) + battle_scepter_list: List["BattleRogueMagicScepter"] = betterproto.message_field(2) + + +@dataclass +class FKOCBOOCDNL(betterproto.Message): + poiiaiakilf: int = betterproto.uint32_field(1) + + +@dataclass +class BattleRogueMagicDetailInfo(betterproto.Message): + battle_magic_item_info: "BattleRogueMagicItemInfo" = betterproto.message_field( + 1 + ) + ennpjglcbem: "FKOCBOOCDNL" = betterproto.message_field(2) + + +@dataclass +class BattleRogueMagicInfo(betterproto.Message): + modifier_content: "BattleRogueMagicModifierInfo" = betterproto.message_field(1) + detail_info: "BattleRogueMagicDetailInfo" = betterproto.message_field(2) + + +@dataclass +class CCCCGJABBPM(betterproto.Message): + scepter_id: int = betterproto.uint32_field(1) + level: int = betterproto.uint32_field(2) + total_damage: float = betterproto.double_field(3) + + +@dataclass +class AENPIJCDBMH(betterproto.Message): + klmcppbbooh: int = betterproto.uint32_field(1) + kmoeadpmflg: int = betterproto.uint32_field(2) + cicanokpnbm: List["CCCCGJABBPM"] = betterproto.message_field(3) + + +@dataclass +class GBNCGKDNMIL(betterproto.Message): + aenkmaoabmp: int = betterproto.uint32_field(1) + mcdpiabdigi: int = betterproto.uint32_field(2) + jnimloiohnh: float = betterproto.double_field(3) + iejjjkfedah: float = betterproto.double_field(4) + + +@dataclass +class MBJHFPCJALN(betterproto.Message): + ehnnecghjal: "GBNCGKDNMIL" = betterproto.message_field(1) + + +@dataclass +class AIGKNHFANGA(betterproto.Message): + eilaabldphm: "AENPIJCDBMH" = betterproto.message_field(1) + inpkgdfmpea: "MBJHFPCJALN" = betterproto.message_field(2) + + +@dataclass +class LHLBIANFOHK(betterproto.Message): + monster_id: int = betterproto.uint32_field(1) + gmlfmpjpegg: int = betterproto.uint32_field(2) + ffpmjfhncho: int = betterproto.uint32_field(3) + gmmbgamhbkb: int = betterproto.uint32_field(4) + + +@dataclass +class LLBMAPHBOGD(betterproto.Message): + acpbmmmcjip: int = betterproto.uint32_field(1) + kkancjaljpo: float = betterproto.double_field(2) + mfjkflgpgko: float = betterproto.double_field(3) + wave: int = betterproto.uint32_field(4) + gmlfmpjpegg: int = betterproto.uint32_field(5) + abmnlnnoklo: float = betterproto.double_field(6) + ihbbekcoeae: float = betterproto.double_field(7) + + +@dataclass +class DPNDLHGEMEI(betterproto.Message): + imcpkldfdog: int = betterproto.uint32_field(1) + ajgeofiiddh: int = betterproto.uint32_field(2) + omoenbakmhj: float = betterproto.double_field(3) + wave: int = betterproto.uint32_field(4) + gmlfmpjpegg: int = betterproto.uint32_field(5) + + +@dataclass +class CPFCBLADMBH(betterproto.Message): + haafhkiagkm: List["LHLBIANFOHK"] = betterproto.message_field(1) + oeagamjdlma: List["LLBMAPHBOGD"] = betterproto.message_field(2) + plennpagjll: List["DPNDLHGEMEI"] = betterproto.message_field(3) + + +@dataclass +class BAAGNOHEHMA(betterproto.Message): + oimbgaehdbi: "CPFCBLADMBH" = betterproto.message_field(1) + + +@dataclass +class MKEECCHGIGH(betterproto.Message): + nmimbiopeki: int = betterproto.uint32_field(1) + kkancjaljpo: float = betterproto.double_field(2) + mfjkflgpgko: float = betterproto.double_field(3) + fgmlckanian: int = betterproto.uint32_field(4) + goaebjjpajo: int = betterproto.uint32_field(5) + nilakidfhej: int = betterproto.uint32_field(6) + pigndajgdgj: int = betterproto.uint32_field(7) + abmnlnnoklo: float = betterproto.double_field(8) + jbjmophgmfa: int = betterproto.uint32_field(9) + pobibiloani: int = betterproto.uint32_field(10) + ihbbekcoeae: float = betterproto.double_field(11) + loollagmnlh: int = betterproto.uint32_field(12) + fkeaaipkpaa: int = betterproto.uint32_field(13) + + +@dataclass +class BDMGOEJBFGL(betterproto.Message): + loollagmnlh: int = betterproto.uint32_field(1) + fkeaaipkpaa: int = betterproto.uint32_field(2) + akpmnjcggai: int = betterproto.uint32_field(3) + oeagamjdlma: List["MKEECCHGIGH"] = betterproto.message_field(4) + + +@dataclass +class HANHNLNEICM(betterproto.Message): + avatar_id: int = betterproto.uint32_field(1) + dpdnnmbcpoi: int = betterproto.uint32_field(2) + total_turns: int = betterproto.uint32_field(3) + fbcmjgmbjfc: float = betterproto.double_field(4) + skill_times: List["SkillUseProperty"] = betterproto.message_field(5) + total_damage: float = betterproto.double_field(6) + total_break_damage: float = betterproto.double_field(7) + attack_type_damage: List["AttackDamageProperty"] = betterproto.message_field(8) + attack_type_break_damage: List["AttackDamageProperty"] = betterproto.message_field( + 9 + ) + attack_type_max_damage: List["AttackDamageProperty"] = betterproto.message_field(10) + total_damage_taken: float = betterproto.double_field(11) + total_heal: float = betterproto.double_field(12) + total_hp_recover: float = betterproto.double_field(13) + total_shield: float = betterproto.double_field(14) + total_shield_taken: float = betterproto.double_field(15) + total_shield_damage: float = betterproto.double_field(16) + break_times: int = betterproto.uint32_field(17) + jeplcjkfomb: int = betterproto.uint32_field(18) + ncjhdjjdjnl: int = betterproto.uint32_field(19) + lkmgdiadopb: int = betterproto.uint32_field(20) + iblgmcipckm: float = betterproto.double_field(21) + entity_id: int = betterproto.uint32_field(22) + + +@dataclass +class PEDJNPJKOCK(betterproto.Message): + avatar_id: int = betterproto.uint32_field(1) + maze_buff_id: int = betterproto.uint32_field(2) + iagenfadhlp: int = betterproto.uint32_field(3) + + +@dataclass +class NMCMOHAHOPL(betterproto.Message): + pccdmdfnjpd: List["HANHNLNEICM"] = betterproto.message_field(1) + hkpbefflfeo: int = betterproto.uint32_field(2) + dfnkmijebld: int = betterproto.uint32_field(3) + + +@dataclass +class BattleStatistics(betterproto.Message): + total_battle_turns: int = betterproto.uint32_field(1) + total_auto_turns: int = betterproto.uint32_field(2) + avatar_id_list: List[int] = betterproto.uint32_field(3) + ultra_cnt: int = betterproto.uint32_field(4) + total_delay_cumulate: float = betterproto.double_field(5) + cost_time: float = betterproto.double_field(6) + battle_avatar_list: List["AvatarBattleInfo"] = betterproto.message_field(7) + monster_list: List["MonsterBattleInfo"] = betterproto.message_field(8) + round_cnt: int = betterproto.uint32_field(9) + cocoon_dead_wave: int = betterproto.uint32_field(10) + avatar_battle_turns: int = betterproto.uint32_field(11) + monster_battle_turns: int = betterproto.uint32_field(12) + custom_values: Dict[str, float] = betterproto.map_field( + 13, betterproto.TYPE_STRING, betterproto.TYPE_FLOAT + ) + challenge_score: int = betterproto.uint32_field(14) + ijolofbjinb: List["BattleEventBattleInfo"] = betterproto.message_field(16) + end_reason: "BattleEndReason" = betterproto.enum_field(19) + glojpnlnhjh: List["IBFFAJOHKMO"] = betterproto.message_field(21) + iiccefcgpak: List[int] = betterproto.int32_field(22) + ldgaanonmbk: List["IIIPHJIMNID"] = betterproto.message_field(23) + adbhgkpnikp: List["MMNDJAMEBML"] = betterproto.message_field(26) + ecefbcnofkb: List["GMKEPCOMHPN"] = betterproto.message_field(27) + battle_target_info: Dict[int, "BattleTargetList"] = betterproto.map_field( + 28, betterproto.TYPE_UINT32, betterproto.TYPE_MESSAGE + ) + najlkhfllpg: List["EAGOCAHFGAF"] = betterproto.message_field(29) + jpgifchjdlk: "EvolveBuildBattleInfo" = betterproto.message_field(30) + mnphnjkgpkl: "CHDONIGOKNM" = betterproto.message_field(31) + leddodammno: bool = betterproto.bool_field(32) + enbjcpkgcol: List["JFFNDOBBNFB"] = betterproto.message_field(33) + ngoknfdmhmf: List["EKBAGMOMECL"] = betterproto.message_field(34) + dkoeadnamcj: int = betterproto.uint32_field(35) + idcgpakjfmd: "AIGKNHFANGA" = betterproto.message_field(36) + billjjbfiol: "BAAGNOHEHMA" = betterproto.message_field(37) + hmpgmiljapb: "BDMGOEJBFGL" = betterproto.message_field(38) + nocigfllifg: "NMCMOHAHOPL" = betterproto.message_field(39) + okgcipahmei: List["PEDJNPJKOCK"] = betterproto.message_field(42) + + +@dataclass +class EAGOCAHFGAF(betterproto.Message): + oefeefglieb: int = betterproto.uint32_field(1) + pbhphhmpaih: int = betterproto.uint32_field(2) + + +@dataclass +class GMKEPCOMHPN(betterproto.Message): + type: "AetherdivideSpiritLineupType" = betterproto.enum_field(1) + id: int = betterproto.uint32_field(2) + sp_bar: "SpBarInfo" = betterproto.message_field(3) + + +@dataclass +class MultiPath(betterproto.Message): + multi_path_type: int = betterproto.uint32_field(1) + level: int = betterproto.uint32_field(2) + exp: int = betterproto.uint32_field(3) + + +@dataclass +class EPHILIMKADK(betterproto.Message): + retcode: "BattleCheckResultType" = betterproto.enum_field(1) + end_status: "BattleEndStatus" = betterproto.enum_field(2) + stt: "BattleStatistics" = betterproto.message_field(3) + game_core_log_encode: bytes = betterproto.bytes_field(4) + dgnmmingacj: Dict[str, int] = betterproto.map_field( + 5, betterproto.TYPE_STRING, betterproto.TYPE_UINT32 + ) + mismatch_turn_count: int = betterproto.uint32_field(6) + mdlpcfcphdk: int = betterproto.uint32_field(7) + + +@dataclass +class CharacterSnapshot(betterproto.Message): + runtime_id: int = betterproto.uint32_field(1) + properties: List[int] = betterproto.uint64_field(2) + + +@dataclass +class AnimEventSnapshot(betterproto.Message): + event_name: str = betterproto.string_field(1) + count: int = betterproto.uint32_field(2) + + +@dataclass +class OODOCMDLOMF(betterproto.Message): + uid: int = betterproto.uint32_field(1) + level: int = betterproto.uint32_field(2) + nickname: str = betterproto.string_field(3) + gfidnaanafh: int = betterproto.uint32_field(4) + platform: "PlatformType" = betterproto.enum_field(5) + akcejfcfban: str = betterproto.string_field(6) + bjellapogjn: str = betterproto.string_field(7) + version: int = betterproto.uint64_field(8) + + +@dataclass +class IDDLKHHLECG(betterproto.Message): + noiiaoidgeo: "LobbyCharacterType" = betterproto.enum_field(1) + status: "LobbyCharacterStatus" = betterproto.enum_field(2) + + +@dataclass +class NJFGJPCANDI(betterproto.Message): + bkmpfeocfib: int = betterproto.uint32_field(1) + cocongacifj: bool = betterproto.bool_field(2) + jejkigabeek: int = betterproto.uint32_field(3) + miafpfpmaca: int = betterproto.uint32_field(4) + + +@dataclass +class LCMIFOBKNEN(betterproto.Message): + mkfdpcckfnf: int = betterproto.uint32_field(1) + rank: int = betterproto.uint32_field(2) + gnigohiaffi: List[int] = betterproto.uint32_field(3) + score_id: int = betterproto.uint32_field(4) + + +@dataclass +class EPEGHCGCMHP(betterproto.Message): + dchdjallnec: "NJFGJPCANDI" = betterproto.message_field(1001) + embbhncjdpk: "LCMIFOBKNEN" = betterproto.message_field(1002) + b_h_g_g_h_f_j_m_m_b_m: List[str] = betterproto.string_field(1) + f_m_o_p_b_f_k_n_l_n_i: bool = betterproto.bool_field(2) + + +@dataclass +class CBBDIOMIFHD(betterproto.Message): + basic_info: "OODOCMDLOMF" = betterproto.message_field(1) + nckccokdkol: "IDDLKHHLECG" = betterproto.message_field(2) + stage_info: "EPEGHCGCMHP" = betterproto.message_field(3) + + +@dataclass +class CDIMEMFJJFP(betterproto.Message): + lmmgodphjne: int = betterproto.uint32_field(1) + pgjccgnbbpi: int = betterproto.uint32_field(2) + nnbhkcjcpio: int = betterproto.uint32_field(3) + khbnjgpphoa: int = betterproto.uint32_field(4) + agdceblfgkh: int = betterproto.uint32_field(5) + dncpbbliopl: int = betterproto.uint32_field(6) + lilifgbafkn: int = betterproto.uint32_field(7) + mmiijhohoge: int = betterproto.uint32_field(8) + iokfikhhang: int = betterproto.uint32_field(9) + cilkfjblejg: int = betterproto.uint32_field(10) + + +@dataclass +class PPGGKMDAOEA(betterproto.Message): + lofamegpmbc: int = betterproto.uint64_field(1) + gbahcdlhacn: "FightGameMode" = betterproto.enum_field(2) + + +@dataclass +class BIPLKGDFAFJ(betterproto.Message): + id: int = betterproto.uint64_field(1) + pdmolplcflg: "FightGameMode" = betterproto.enum_field(2) + iihpmlibbeb: List["CBBDIOMIFHD"] = betterproto.message_field(3) + type: "MatchUnitType" = betterproto.enum_field(4) + infhikbljla: int = betterproto.uint64_field(5) + mlelajdljnl: int = betterproto.uint64_field(6) + jbnenlhccbh: int = betterproto.uint32_field(7) + + +@dataclass +class LoginActivityData(betterproto.Message): + panel_id: int = betterproto.uint32_field(6) + jlhoggdhmhg: List[int] = betterproto.uint32_field(7) + login_days: int = betterproto.uint32_field(3) + id: int = betterproto.uint32_field(12) + + +@dataclass +class GetLoginActivityCsReq(betterproto.Message): + pass + + +@dataclass +class GetLoginActivityScRsp(betterproto.Message): + login_activity_list: List["LoginActivityData"] = betterproto.message_field(2) + retcode: int = betterproto.uint32_field(9) + + +@dataclass +class TakeLoginActivityRewardCsReq(betterproto.Message): + take_days: int = betterproto.uint32_field(2) + id: int = betterproto.uint32_field(14) + + +@dataclass +class TakeLoginActivityRewardScRsp(betterproto.Message): + take_days: int = betterproto.uint32_field(3) + id: int = betterproto.uint32_field(8) + panel_id: int = betterproto.uint32_field(13) + reward: "ItemList" = betterproto.message_field(4) + retcode: int = betterproto.uint32_field(1) + + +@dataclass +class ActivityScheduleData(betterproto.Message): + activity_id: int = betterproto.uint32_field(6) + panel_id: int = betterproto.uint32_field(10) + end_time: int = betterproto.int64_field(9) + begin_time: int = betterproto.int64_field(12) + + +@dataclass +class GetActivityScheduleConfigCsReq(betterproto.Message): + pass + + +@dataclass +class GetActivityScheduleConfigScRsp(betterproto.Message): + schedule_data: List["ActivityScheduleData"] = betterproto.message_field(13) + retcode: int = betterproto.uint32_field(2) + + +@dataclass +class TrialActivityInfo(betterproto.Message): + stage_id: int = betterproto.uint32_field(8) + taken_reward: bool = betterproto.bool_field(15) + + +@dataclass +class GetTrialActivityDataCsReq(betterproto.Message): + pass + + +@dataclass +class GetTrialActivityDataScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(11) + activity_stage_id: int = betterproto.uint32_field(9) + trial_activity_info_list: List["TrialActivityInfo"] = betterproto.message_field(5) + + +@dataclass +class TrialActivityDataChangeScNotify(betterproto.Message): + trial_activity_info: "TrialActivityInfo" = betterproto.message_field(7) + + +@dataclass +class EnterTrialActivityStageCsReq(betterproto.Message): + stage_id: int = betterproto.uint32_field(13) + + +@dataclass +class EnterTrialActivityStageScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(11) + battle_info: "SceneBattleInfo" = betterproto.message_field(6) + + +@dataclass +class TakeTrialActivityRewardCsReq(betterproto.Message): + stage_id: int = betterproto.uint32_field(13) + + +@dataclass +class TakeTrialActivityRewardScRsp(betterproto.Message): + stage_id: int = betterproto.uint32_field(6) + retcode: int = betterproto.uint32_field(4) + reward: "ItemList" = betterproto.message_field(7) + + +@dataclass +class StartTrialActivityCsReq(betterproto.Message): + stage_id: int = betterproto.uint32_field(2) + + +@dataclass +class StartTrialActivityScRsp(betterproto.Message): + stage_id: int = betterproto.uint32_field(2) + retcode: int = betterproto.uint32_field(10) + + +@dataclass +class LeaveTrialActivityCsReq(betterproto.Message): + stage_id: int = betterproto.uint32_field(6) + + +@dataclass +class LeaveTrialActivityScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(7) + stage_id: int = betterproto.uint32_field(4) + + +@dataclass +class CurTrialActivityScNotify(betterproto.Message): + status: "TrialActivityStatus" = betterproto.enum_field(7) + activity_stage_id: int = betterproto.uint32_field(6) + + +@dataclass +class BCEKBNMNHOO(betterproto.Message): + is_taken_reward: bool = betterproto.bool_field(12) + panel_id: int = betterproto.uint32_field(4) + cbnffemdbkf: bool = betterproto.bool_field(11) + pehofbbdnic: int = betterproto.uint32_field(5) + + +@dataclass +class GetMaterialSubmitActivityDataCsReq(betterproto.Message): + pass + + +@dataclass +class GetMaterialSubmitActivityDataScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(2) + nblhgehlodn: List["BCEKBNMNHOO"] = betterproto.message_field(7) + + +@dataclass +class SubmitMaterialSubmitActivityMaterialCsReq(betterproto.Message): + pehofbbdnic: int = betterproto.uint32_field(3) + + +@dataclass +class SubmitMaterialSubmitActivityMaterialScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(14) + blaaoiaeiah: "BCEKBNMNHOO" = betterproto.message_field(11) + + +@dataclass +class TakeMaterialSubmitActivityRewardCsReq(betterproto.Message): + pehofbbdnic: int = betterproto.uint32_field(12) + + +@dataclass +class TakeMaterialSubmitActivityRewardScRsp(betterproto.Message): + pehofbbdnic: int = betterproto.uint32_field(1) + reward: "ItemList" = betterproto.message_field(15) + retcode: int = betterproto.uint32_field(7) + + +@dataclass +class GetAvatarDeliverRewardActivityDataCsReq(betterproto.Message): + pass + + +@dataclass +class GetAvatarDeliverRewardActivityDataScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(6) + avatar_id: int = betterproto.uint32_field(2) + is_taken_reward: bool = betterproto.bool_field(5) + + +@dataclass +class AvatarDeliverRewardChooseAvatarCsReq(betterproto.Message): + avatar_id: int = betterproto.uint32_field(6) + + +@dataclass +class AvatarDeliverRewardChooseAvatarScRsp(betterproto.Message): + avatar_id: int = betterproto.uint32_field(6) + retcode: int = betterproto.uint32_field(15) + + +@dataclass +class AvatarDeliverRewardTakeRewardCsReq(betterproto.Message): + pass + + +@dataclass +class AvatarDeliverRewardTakeRewardScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(14) + reward: "ItemList" = betterproto.message_field(8) + + +@dataclass +class EnterAdventureCsReq(betterproto.Message): + map_id: int = betterproto.uint32_field(4) + + +@dataclass +class EnterAdventureScRsp(betterproto.Message): + scene: "SceneInfo" = betterproto.message_field(2) + retcode: int = betterproto.uint32_field(13) + + +@dataclass +class FarmStageGachaInfo(betterproto.Message): + end_time: int = betterproto.int64_field(11) + gacha_id: int = betterproto.uint32_field(4) + begin_time: int = betterproto.int64_field(5) + + +@dataclass +class GetFarmStageGachaInfoCsReq(betterproto.Message): + farm_stage_gacha_id_list: List[int] = betterproto.uint32_field(9) + + +@dataclass +class GetFarmStageGachaInfoScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(3) + farm_stage_gacha_info_list: List["FarmStageGachaInfo"] = betterproto.message_field( + 4 + ) + + +@dataclass +class QuickStartCocoonStageCsReq(betterproto.Message): + wave: int = betterproto.uint32_field(10) + world_level: int = betterproto.uint32_field(13) + cocoon_id: int = betterproto.uint32_field(6) + + +@dataclass +class QuickStartCocoonStageScRsp(betterproto.Message): + battle_info: "SceneBattleInfo" = betterproto.message_field(9) + wave: int = betterproto.uint32_field(11) + cocoon_id: int = betterproto.uint32_field(4) + retcode: int = betterproto.uint32_field(12) + + +@dataclass +class QuickStartFarmElementCsReq(betterproto.Message): + world_level: int = betterproto.uint32_field(1) + jdanoknhnhl: int = betterproto.uint32_field(13) + + +@dataclass +class QuickStartFarmElementScRsp(betterproto.Message): + jdanoknhnhl: int = betterproto.uint32_field(12) + battle_info: "SceneBattleInfo" = betterproto.message_field(2) + world_level: int = betterproto.uint32_field(11) + retcode: int = betterproto.uint32_field(7) + + +@dataclass +class CocoonSweepCsReq(betterproto.Message): + world_level: int = betterproto.uint32_field(2) + cocoon_id: int = betterproto.uint32_field(10) + + +@dataclass +class CocoonSweepScRsp(betterproto.Message): + drop_data: "ItemList" = betterproto.message_field(11) + multiple_drop_data: "ItemList" = betterproto.message_field(12) + cocoon_id: int = betterproto.uint32_field(3) + retcode: int = betterproto.uint32_field(6) + + +@dataclass +class FarmElementSweepCsReq(betterproto.Message): + world_level: int = betterproto.uint32_field(12) + jdanoknhnhl: int = betterproto.uint32_field(6) + + +@dataclass +class FarmElementSweepScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(7) + jdanoknhnhl: int = betterproto.uint32_field(11) + multiple_drop_data: "ItemList" = betterproto.message_field(5) + + +@dataclass +class EnterAetherDivideSceneCsReq(betterproto.Message): + bdkngdocpgp: int = betterproto.uint32_field(6) + + +@dataclass +class EnterAetherDivideSceneScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(15) + bdkngdocpgp: int = betterproto.uint32_field(7) + + +@dataclass +class LeaveAetherDivideSceneCsReq(betterproto.Message): + pass + + +@dataclass +class LeaveAetherDivideSceneScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(6) + + +@dataclass +class StartAetherDivideSceneBattleCsReq(betterproto.Message): + cast_entity_id: int = betterproto.uint32_field(1) + assist_monster_entity_info: List["AssistMonsterEntityInfo"] = ( + betterproto.message_field(9) + ) + assist_monster_entity_id_list: List[int] = betterproto.uint32_field(5) + attacked_by_entity_id: int = betterproto.uint32_field(8) + skill_index: int = betterproto.uint32_field(4) + + +@dataclass +class StartAetherDivideSceneBattleScRsp(betterproto.Message): + cast_entity_id: int = betterproto.uint32_field(7) + retcode: int = betterproto.uint32_field(2) + battle_info: "AetherDivideBattleInfo" = betterproto.message_field(12) + + +@dataclass +class StartAetherDivideChallengeBattleCsReq(betterproto.Message): + lineup_index: int = betterproto.uint32_field(8) + challenge_id: int = betterproto.uint32_field(14) + + +@dataclass +class StartAetherDivideChallengeBattleScRsp(betterproto.Message): + battle_info: "AetherDivideBattleInfo" = betterproto.message_field(9) + retcode: int = betterproto.uint32_field(10) + + +@dataclass +class PassiveSkillItem(betterproto.Message): + slot: int = betterproto.uint32_field(14) + item_id: int = betterproto.uint32_field(10) + + +@dataclass +class AetherDivideSpiritInfo(betterproto.Message): + promotion: int = betterproto.uint32_field(11) + exp: int = betterproto.uint32_field(9) + sp_bar: "SpBarInfo" = betterproto.message_field(5) + aether_avatar_id: int = betterproto.uint32_field(4) + jdhchabclcc: int = betterproto.uint32_field(7) + passive_skill: List["PassiveSkillItem"] = betterproto.message_field(10) + + +@dataclass +class AetherDivideLineupInfo(betterproto.Message): + slot: int = betterproto.uint32_field(11) + aether_avatar_list: List[int] = betterproto.uint32_field(8) + + +@dataclass +class AetherSkillInfo(betterproto.Message): + num: int = betterproto.uint32_field(12) + skill_dress_avatar_id: int = betterproto.uint32_field(11) + item_id: int = betterproto.uint32_field(2) + + +@dataclass +class GetAetherDivideInfoCsReq(betterproto.Message): + pass + + +@dataclass +class GetAetherDivideInfoScRsp(betterproto.Message): + lineup_list: List["AetherDivideLineupInfo"] = betterproto.message_field(6) + skill_list: List["AetherSkillInfo"] = betterproto.message_field(10) + phlkdnghooa: int = betterproto.uint32_field(1) + jdhlmhjbojm: int = betterproto.uint32_field(14) + pfljggdaofm: int = betterproto.uint32_field(9) + nlfihkicddo: List["AetherDivideSpiritInfo"] = betterproto.message_field(4) + retcode: int = betterproto.uint32_field(8) + egemndnedip: int = betterproto.uint32_field(15) + ibcipiidcol: int = betterproto.uint32_field(2) + + +@dataclass +class SetAetherDivideLineUpCsReq(betterproto.Message): + lineup: "AetherDivideLineupInfo" = betterproto.message_field(13) + + +@dataclass +class SetAetherDivideLineUpScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(7) + lineup: "AetherDivideLineupInfo" = betterproto.message_field(5) + + +@dataclass +class EquipAetherDividePassiveSkillCsReq(betterproto.Message): + slot: int = betterproto.uint32_field(2) + item_id: int = betterproto.uint32_field(9) + aether_avatar_id: int = betterproto.uint32_field(4) + + +@dataclass +class EquipAetherDividePassiveSkillScRsp(betterproto.Message): + aether_skill_info: "AetherSkillInfo" = betterproto.message_field(8) + aether_info: "AetherDivideSpiritInfo" = betterproto.message_field(7) + retcode: int = betterproto.uint32_field(6) + + +@dataclass +class ClearAetherDividePassiveSkillCsReq(betterproto.Message): + aether_avatar_id: int = betterproto.uint32_field(2) + slot: int = betterproto.uint32_field(13) + + +@dataclass +class ClearAetherDividePassiveSkillScRsp(betterproto.Message): + aether_skill_info: "AetherSkillInfo" = betterproto.message_field(8) + aether_info: "AetherDivideSpiritInfo" = betterproto.message_field(13) + retcode: int = betterproto.uint32_field(10) + + +@dataclass +class AetherDivideSpiritExpUpCsReq(betterproto.Message): + aether_avatar_id: int = betterproto.uint32_field(1) + jdhlmhjbojm: int = betterproto.uint32_field(9) + kbmlajoaane: int = betterproto.uint32_field(11) + + +@dataclass +class AetherDivideSpiritExpUpScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(10) + jdhlmhjbojm: int = betterproto.uint32_field(11) + aether_info: "AetherDivideSpiritInfo" = betterproto.message_field(2) + + +@dataclass +class SwitchAetherDivideLineUpSlotCsReq(betterproto.Message): + lineup_index: int = betterproto.uint32_field(7) + + +@dataclass +class SwitchAetherDivideLineUpSlotScRsp(betterproto.Message): + lineup_index: int = betterproto.uint32_field(1) + retcode: int = betterproto.uint32_field(13) + + +@dataclass +class StartAetherDivideStageBattleCsReq(betterproto.Message): + event_id: int = betterproto.uint32_field(10) + + +@dataclass +class StartAetherDivideStageBattleScRsp(betterproto.Message): + battle_info: "AetherDivideBattleInfo" = betterproto.message_field(15) + retcode: int = betterproto.uint32_field(6) + + +@dataclass +class AetherDivideLineupScNotify(betterproto.Message): + lineup: "AetherDivideLineupInfo" = betterproto.message_field(5) + + +@dataclass +class AetherDivideSpiritInfoScNotify(betterproto.Message): + mgegimbbajb: List["AetherDivideSpiritInfo"] = betterproto.message_field(15) + jdhlmhjbojm: int = betterproto.uint32_field(11) + aether_info: "AetherDivideSpiritInfo" = betterproto.message_field(10) + + +@dataclass +class GetAetherDivideChallengeInfoCsReq(betterproto.Message): + pass + + +@dataclass +class GetAetherDivideChallengeInfoScRsp(betterproto.Message): + pcnnmjbjioc: int = betterproto.uint32_field(13) + bfdipgblmmo: List[int] = betterproto.uint32_field(7) + gkhjkfcccgp: List[int] = betterproto.uint32_field(12) + retcode: int = betterproto.uint32_field(6) + + +@dataclass +class AetherDivideFinishChallengeScNotify(betterproto.Message): + challenge_id: int = betterproto.uint32_field(4) + + +@dataclass +class AetherDivideTainerInfoScNotify(betterproto.Message): + egemndnedip: int = betterproto.uint32_field(11) + + +@dataclass +class AetherDivideSkillItemScNotify(betterproto.Message): + num: int = betterproto.uint32_field(9) + item_id: int = betterproto.uint32_field(5) + + +@dataclass +class AetherDivideRefreshEndlessCsReq(betterproto.Message): + pass + + +@dataclass +class AetherDivideRefreshEndlessScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(7) + ibcipiidcol: int = betterproto.uint32_field(9) + + +@dataclass +class AetherDivideRefreshEndlessScNotify(betterproto.Message): + ibcipiidcol: int = betterproto.uint32_field(5) + + +@dataclass +class AetherDivideTakeChallengeRewardCsReq(betterproto.Message): + challenge_id: int = betterproto.uint32_field(7) + + +@dataclass +class AetherDivideTakeChallengeRewardScRsp(betterproto.Message): + reward: "ItemList" = betterproto.message_field(14) + challenge_id: int = betterproto.uint32_field(9) + retcode: int = betterproto.uint32_field(15) + + +@dataclass +class JONGAGACHHO(betterproto.Message): + pass + + +@dataclass +class ADOLEOFEGOK(betterproto.Message): + poiiaiakilf: int = betterproto.uint32_field(10) + map_id: int = betterproto.uint32_field(12) + + +@dataclass +class GetAlleyInfoCsReq(betterproto.Message): + level: int = betterproto.uint32_field(13) + shop_id: int = betterproto.uint32_field(14) + + +@dataclass +class AGADEMAJIMD(betterproto.Message): + hnfojbcjamg: List["NJAOIGGMEAL"] = betterproto.message_field(10) + fmjplhohbab: List["LogisticsScore"] = betterproto.message_field(3) + immlphdnmol: List["ADOLEOFEGOK"] = betterproto.message_field(14) + omngcijalfm: List[int] = betterproto.uint32_field(12) + + +@dataclass +class GetAlleyInfoScRsp(betterproto.Message): + nopodeimffb: int = betterproto.uint32_field(15) + bokolcpkejm: "ECJMJJKJGOP" = betterproto.message_field(8) + bjcmphlpknf: List["HEHAOMIAMGL"] = betterproto.message_field(12) + nplakeokekb: Dict[int, int] = betterproto.map_field( + 9, betterproto.TYPE_UINT32, betterproto.TYPE_UINT32 + ) + gefndeeikef: List[int] = betterproto.uint32_field(4) + oedpopcohgb: List[int] = betterproto.uint32_field(3) + njgamccgadc: "AGADEMAJIMD" = betterproto.message_field(11) + glboemjjahd: List[int] = betterproto.uint32_field(2) + level: int = betterproto.uint32_field(7) + retcode: int = betterproto.uint32_field(5) + klpngfnmipi: "LAIEMCFACDK" = betterproto.message_field(1) + cur_fund: int = betterproto.uint32_field(10) + + +@dataclass +class KFAIFHOPNHH(betterproto.Message): + bddldnejfkn: int = betterproto.uint32_field(2) + iffppglafnb: int = betterproto.uint32_field(12) + + +@dataclass +class KGCANLJIKCP(betterproto.Message): + kalfmcaghdo: List["KFAIFHOPNHH"] = betterproto.message_field(14) + goods_id: int = betterproto.uint32_field(8) + + +@dataclass +class AlleyPlacingShip(betterproto.Message): + goods_list: List["KGCANLJIKCP"] = betterproto.message_field(12) + ship_id: int = betterproto.uint32_field(1) + + +@dataclass +class AlleyPlacingGameCsReq(betterproto.Message): + indeplofdec: int = betterproto.uint32_field(10) + cost_time: int = betterproto.uint32_field(13) + hlojkekipkf: int = betterproto.uint32_field(2) + engdbiimaff: int = betterproto.uint32_field(6) + bmnhhidhodd: int = betterproto.uint32_field(11) + fjdabppandc: int = betterproto.uint32_field(4) + ejjodhjhham: "AlleyPlacingShip" = betterproto.message_field(15) + dhhjlchclaf: int = betterproto.uint32_field(5) + keokdnikbda: int = betterproto.uint32_field(8) + + +@dataclass +class AlleyPlacingGameScRsp(betterproto.Message): + koficklljni: int = betterproto.uint32_field(14) + event_id: int = betterproto.uint32_field(2) + retcode: int = betterproto.uint32_field(4) + khibbgphdmb: int = betterproto.uint32_field(15) + elbbanddjci: int = betterproto.uint32_field(7) + ilegfkgcmom: int = betterproto.uint32_field(1) + kfboklhdjda: int = betterproto.uint32_field(13) + pglgblkkida: int = betterproto.uint32_field(9) + + +@dataclass +class ActivityRaidPlacingGameCsReq(betterproto.Message): + cjemmdpiclj: int = betterproto.uint32_field(14) + fjdabppandc: int = betterproto.uint32_field(1) + e_j_j_o_d_h_j_h_h_a_m: "AlleyPlacingShip" = betterproto.message_field(11) + + +@dataclass +class ActivityRaidPlacingGameScRsp(betterproto.Message): + cjemmdpiclj: int = betterproto.uint32_field(4) + fjdabppandc: int = betterproto.uint32_field(13) + retcode: int = betterproto.uint32_field(7) + + +@dataclass +class ECJMJJKJGOP(betterproto.Message): + hdkdkjbdgcc: int = betterproto.uint32_field(3) + jdjcnbgoglp: List[int] = betterproto.uint32_field(10) + fbeildajede: List[int] = betterproto.uint32_field(1) + cpgajpckcdg: int = betterproto.uint32_field(2) + jalhneidhgj: int = betterproto.uint32_field(14) + iichhokopgg: bool = betterproto.bool_field(7) + + +@dataclass +class AlleyOrderChangedScNotify(betterproto.Message): + pphiadnkgaf: "ECJMJJKJGOP" = betterproto.message_field(1) + + +@dataclass +class AlleyShipUnlockScNotify(betterproto.Message): + ejdfknmnale: int = betterproto.uint32_field(14) + + +@dataclass +class LLLOMACPCGB(betterproto.Message): + lepacdhlbib: int = betterproto.uint32_field(9) + shop_id: int = betterproto.uint32_field(8) + dgnkgdlillb: List[int] = betterproto.uint32_field(13) + behpabeeodh: int = betterproto.uint32_field(12) + cadhphlnoch: List[int] = betterproto.uint32_field(11) + ppibbkhlmjc: List[int] = betterproto.uint32_field(10) + cakccbjohoi: int = betterproto.uint32_field(15) + + +@dataclass +class NJAOIGGMEAL(betterproto.Message): + hofdbflcgkb: List["LLLOMACPCGB"] = betterproto.message_field(15) + cost_time: int = betterproto.uint32_field(4) + map_id: int = betterproto.uint32_field(1) + + +@dataclass +class LogisticsScore(betterproto.Message): + unlock_level: int = betterproto.uint32_field(7) + max_score: int = betterproto.uint32_field(11) + last_level: int = betterproto.uint32_field(12) + last_max_score: int = betterproto.uint32_field(4) + cur_score: int = betterproto.uint32_field(5) + reward: "ItemList" = betterproto.message_field(1) + map_id: int = betterproto.uint32_field(10) + + +@dataclass +class LogisticsGameCsReq(betterproto.Message): + apmcphfmaeg: List["NJAOIGGMEAL"] = betterproto.message_field(12) + boblnbjmkca: bool = betterproto.bool_field(2) + + +@dataclass +class LogisticsScoreRewardSyncInfoScNotify(betterproto.Message): + fmjplhohbab: List["LogisticsScore"] = betterproto.message_field(8) + + +@dataclass +class LogisticsGameScRsp(betterproto.Message): + event_id: int = betterproto.uint32_field(11) + retcode: int = betterproto.uint32_field(8) + fmjplhohbab: List["LogisticsScore"] = betterproto.message_field(14) + boblnbjmkca: bool = betterproto.bool_field(2) + + +@dataclass +class HEHAOMIAMGL(betterproto.Message): + state: "AlleyEventState" = betterproto.enum_field(9) + event_id: int = betterproto.uint32_field(4) + ningbnbmkop: int = betterproto.uint32_field(7) + + +@dataclass +class StartAlleyEventCsReq(betterproto.Message): + event_id: int = betterproto.uint32_field(15) + + +@dataclass +class StartAlleyEventScRsp(betterproto.Message): + event_id: int = betterproto.uint32_field(12) + retcode: int = betterproto.uint32_field(10) + + +@dataclass +class AlleyEventChangeNotify(betterproto.Message): + nfldodiabcl: "HEHAOMIAMGL" = betterproto.message_field(12) + hcnldibeaca: int = betterproto.uint32_field(1) + + +@dataclass +class AlleyEventEffectNotify(betterproto.Message): + lfilnmfdnig: int = betterproto.uint32_field(6) + + +@dataclass +class TakePrestigeRewardCsReq(betterproto.Message): + level: int = betterproto.uint32_field(2) + + +@dataclass +class TakePrestigeRewardScRsp(betterproto.Message): + reward: "ItemList" = betterproto.message_field(1) + retcode: int = betterproto.uint32_field(4) + level: int = betterproto.uint32_field(10) + + +@dataclass +class PrestigeLevelUpCsReq(betterproto.Message): + pass + + +@dataclass +class PrestigeLevelUpScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(4) + level: int = betterproto.uint32_field(12) + + +@dataclass +class AlleyFundsScNotify(betterproto.Message): + cur_fund: int = betterproto.uint32_field(8) + + +@dataclass +class SaveLogisticsCsReq(betterproto.Message): + apmcphfmaeg: List["NJAOIGGMEAL"] = betterproto.message_field(15) + + +@dataclass +class SaveLogisticsScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(6) + apmcphfmaeg: List["NJAOIGGMEAL"] = betterproto.message_field(15) + + +@dataclass +class LogisticsInfoScNotify(betterproto.Message): + njgamccgadc: "AGADEMAJIMD" = betterproto.message_field(10) + + +@dataclass +class LAIEMCFACDK(betterproto.Message): + alghcnajbmm: int = betterproto.uint32_field(6) + pghckcpkgll: int = betterproto.uint32_field(7) + aahapcbilhc: Dict[int, int] = betterproto.map_field( + 10, betterproto.TYPE_UINT32, betterproto.TYPE_UINT32 + ) + + +@dataclass +class AlleyShipmentEventEffectsScNotify(betterproto.Message): + lgjkpjojblf: "LAIEMCFACDK" = betterproto.message_field(8) + + +@dataclass +class GetSaveLogisticsMapCsReq(betterproto.Message): + pass + + +@dataclass +class GetSaveLogisticsMapScRsp(betterproto.Message): + hnfojbcjamg: List["NJAOIGGMEAL"] = betterproto.message_field(1) + retcode: int = betterproto.uint32_field(11) + + +@dataclass +class AlleyShipUsedCountScNotify(betterproto.Message): + nplakeokekb: Dict[int, int] = betterproto.map_field( + 1, betterproto.TYPE_UINT32, betterproto.TYPE_UINT32 + ) + + +@dataclass +class AlleyGuaranteedFundsCsReq(betterproto.Message): + pass + + +@dataclass +class AlleyGuaranteedFundsScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(14) + clibobehndm: int = betterproto.uint32_field(4) + + +@dataclass +class AlleyTakeEventRewardCsReq(betterproto.Message): + event_id: int = betterproto.uint32_field(12) + + +@dataclass +class AlleyTakeEventRewardScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(10) + reward: "ItemList" = betterproto.message_field(3) + + +@dataclass +class LogisticsDetonateStarSkiffCsReq(betterproto.Message): + pass + + +@dataclass +class LogisticsDetonateStarSkiffScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(15) + + +@dataclass +class RelicList(betterproto.Message): + type: int = betterproto.uint32_field(3) + set_id: int = betterproto.uint32_field(6) + + +@dataclass +class MonsterList(betterproto.Message): + num: int = betterproto.uint32_field(5) + monster_id: int = betterproto.uint32_field(14) + + +@dataclass +class ArchiveData(betterproto.Message): + relic_list: List["RelicList"] = betterproto.message_field(9) + kill_monster_list: List["MonsterList"] = betterproto.message_field(6) + archive_avatar_id_list: List[int] = betterproto.uint32_field(2) + archive_equipment_id_list: List[int] = betterproto.uint32_field(7) + archive_missing_equipment_id_list: List[int] = betterproto.uint32_field(14) + + +@dataclass +class GetArchiveDataCsReq(betterproto.Message): + pass + + +@dataclass +class GetArchiveDataScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(4) + archive_data: "ArchiveData" = betterproto.message_field(10) + + +@dataclass +class GetUpdatedArchiveDataCsReq(betterproto.Message): + pass + + +@dataclass +class GetUpdatedArchiveDataScRsp(betterproto.Message): + archive_data: "ArchiveData" = betterproto.message_field(8) + retcode: int = betterproto.uint32_field(15) + + +@dataclass +class GetAvatarDataCsReq(betterproto.Message): + is_get_all: bool = betterproto.bool_field(10) + base_avatar_id_list: List[int] = betterproto.uint32_field(11) + + +@dataclass +class EquipRelic(betterproto.Message): + type: int = betterproto.uint32_field(4) + relic_unique_id: int = betterproto.uint32_field(11) + + +@dataclass +class Avatar(betterproto.Message): + first_met_time_stamp: int = betterproto.uint64_field(4) + equip_relic_list: List["EquipRelic"] = betterproto.message_field(11) + dressed_skin_id: int = betterproto.uint32_field(5) + skilltree_list: List["AvatarSkillTree"] = betterproto.message_field(10) + equipment_unique_id: int = betterproto.uint32_field(12) + rank: int = betterproto.uint32_field(6) + has_taken_promotion_reward_list: List[int] = betterproto.uint32_field(7) + is_marked: bool = betterproto.bool_field(2) + exp: int = betterproto.uint32_field(9) + promotion: int = betterproto.uint32_field(14) + base_avatar_id: int = betterproto.uint32_field(3) + level: int = betterproto.uint32_field(13) + + +@dataclass +class GetAvatarDataScRsp(betterproto.Message): + is_get_all: bool = betterproto.bool_field(14) + jpnlpopmkej: int = betterproto.uint32_field(5) + skin_list: List[int] = betterproto.uint32_field(13) + pnkcfealami: List["GrowthTartgetFuncType"] = betterproto.enum_field(1) + avatar_list: List["Avatar"] = betterproto.message_field(10) + retcode: int = betterproto.uint32_field(11) + + +@dataclass +class AvatarExpUpCsReq(betterproto.Message): + item_cost: "ItemCostData" = betterproto.message_field(6) + base_avatar_id: int = betterproto.uint32_field(5) + + +@dataclass +class AvatarExpUpScRsp(betterproto.Message): + return_item_list: List["PileItem"] = betterproto.message_field(2) + retcode: int = betterproto.uint32_field(9) + + +@dataclass +class UnlockSkilltreeCsReq(betterproto.Message): + item_list: List["ItemCost"] = betterproto.message_field(3) + level: int = betterproto.uint32_field(2) + point_id: int = betterproto.uint32_field(1) + + +@dataclass +class UnlockSkilltreeScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(2) + point_id: int = betterproto.uint32_field(6) + level: int = betterproto.uint32_field(8) + + +@dataclass +class PromoteAvatarCsReq(betterproto.Message): + base_avatar_id: int = betterproto.uint32_field(7) + item_list: List["ItemCost"] = betterproto.message_field(9) + + +@dataclass +class PromoteAvatarScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(10) + + +@dataclass +class DressAvatarCsReq(betterproto.Message): + equipment_unique_id: int = betterproto.uint32_field(12) + avatar_id: int = betterproto.uint32_field(15) + + +@dataclass +class DressAvatarScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(4) + + +@dataclass +class TakeOffEquipmentCsReq(betterproto.Message): + avatar_id: int = betterproto.uint32_field(9) + + +@dataclass +class TakeOffEquipmentScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(13) + + +@dataclass +class AddAvatarScNotify(betterproto.Message): + src: "AddAvatarSrcState" = betterproto.enum_field(14) + base_avatar_id: int = betterproto.uint32_field(9) + is_new: bool = betterproto.bool_field(2) + reward: "ItemList" = betterproto.message_field(8) + + +@dataclass +class AddMultiPathAvatarScNotify(betterproto.Message): + reward: "ItemList" = betterproto.message_field(2) + is_new: bool = betterproto.bool_field(12) + avatar_id: int = betterproto.uint32_field(4) + + +@dataclass +class RankUpAvatarCsReq(betterproto.Message): + cost_data: "ItemCostData" = betterproto.message_field(2) + avatar_id: int = betterproto.uint32_field(11) + rank: int = betterproto.uint32_field(7) + + +@dataclass +class RankUpAvatarScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(13) + + +@dataclass +class DressRelicParam(betterproto.Message): + relic_type: int = betterproto.uint32_field(11) + relic_unique_id: int = betterproto.uint32_field(13) + + +@dataclass +class DressRelicAvatarCsReq(betterproto.Message): + avatar_id: int = betterproto.uint32_field(2) + switch_list: List["DressRelicParam"] = betterproto.message_field(8) + + +@dataclass +class DressRelicAvatarScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(6) + + +@dataclass +class TakeOffRelicCsReq(betterproto.Message): + avatar_id: int = betterproto.uint32_field(8) + relic_type_list: List[int] = betterproto.uint32_field(15) + + +@dataclass +class TakeOffRelicScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(15) + + +@dataclass +class TakePromotionRewardCsReq(betterproto.Message): + promotion: int = betterproto.uint32_field(11) + base_avatar_id: int = betterproto.uint32_field(10) + + +@dataclass +class TakePromotionRewardScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(10) + reward_list: "ItemList" = betterproto.message_field(5) + + +@dataclass +class DressAvatarSkinCsReq(betterproto.Message): + skin_id: int = betterproto.uint32_field(15) + avatar_id: int = betterproto.uint32_field(4) + + +@dataclass +class DressAvatarSkinScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(14) + + +@dataclass +class TakeOffAvatarSkinCsReq(betterproto.Message): + avatar_id: int = betterproto.uint32_field(6) + + +@dataclass +class TakeOffAvatarSkinScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(10) + + +@dataclass +class UnlockAvatarSkinScNotify(betterproto.Message): + skin_id: int = betterproto.uint32_field(1) + + +@dataclass +class MarkAvatarCsReq(betterproto.Message): + avatar_id: int = betterproto.uint32_field(5) + is_marked: bool = betterproto.bool_field(3) + + +@dataclass +class MarkAvatarScRsp(betterproto.Message): + is_marked: bool = betterproto.bool_field(9) + avatar_id: int = betterproto.uint32_field(1) + retcode: int = betterproto.uint32_field(15) + + +@dataclass +class SetGrowthTargetAvatarCsReq(betterproto.Message): + idnmeknhlpo: int = betterproto.uint32_field(14) + avatar_id: int = betterproto.uint32_field(7) + growth_target_type_list: List["GrowthTartgetFuncType"] = betterproto.enum_field(1) + source: "GrowthTargetState" = betterproto.enum_field(3) + + +@dataclass +class SetGrowthTargetAvatarScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(7) + growth_target_type_list: List["GrowthTartgetFuncType"] = betterproto.enum_field(5) + ncbkpdngohj: int = betterproto.uint32_field(14) + jpnlpopmkej: int = betterproto.uint32_field(9) + + +@dataclass +class GrowthTargetAvatarChangedScNotify(betterproto.Message): + jpnlpopmkej: int = betterproto.uint32_field(8) + growth_target_type_list: List["GrowthTartgetFuncType"] = betterproto.enum_field(15) + + +@dataclass +class GetPreAvatarGrowthInfoCsReq(betterproto.Message): + kjaeojbjojd: int = betterproto.uint32_field(1) + + +@dataclass +class GetPreAvatarGrowthInfoScRsp(betterproto.Message): + flaagnapdhp: int = betterproto.uint32_field(10) + ebppbpmhdhi: str = betterproto.string_field(1911) + jjmkeadciag: int = betterproto.uint32_field(13) + aekfjkenphn: int = betterproto.uint32_field(4) + phibnkmiogp: int = betterproto.uint32_field(7) + lkkamllafae: int = betterproto.uint32_field(12) + fojcckacdhh: int = betterproto.uint32_field(6) + hdnikcblkil: int = betterproto.uint32_field(8) + lijcngohkhf: int = betterproto.uint32_field(5) + pmmcfgmplba: int = betterproto.uint32_field(14) + kjaeojbjojd: int = betterproto.uint32_field(9) + dggnnbcjocc: int = betterproto.uint32_field(221) + kpjhbeilaip: str = betterproto.string_field(1269) + dlapkbddbbc: int = betterproto.uint32_field(1) + kiejacmogan: int = betterproto.uint32_field(1486) + dbijfkobkkh: int = betterproto.uint32_field(11) + oanpnfjjfhg: str = betterproto.string_field(508) + egddnpeonkc: int = betterproto.uint32_field(15) + mkhldlfonkn: str = betterproto.string_field(426) + ihokhlfhocc: int = betterproto.uint32_field(2) + retcode: int = betterproto.uint32_field(3) + + +@dataclass +class OPPGLJBHKLL(betterproto.Message): + type: int = betterproto.uint32_field(13) + kjaeojbjojd: int = betterproto.uint32_field(14) + panel_id: int = betterproto.uint32_field(3) + + +@dataclass +class GetPreAvatarListCsReq(betterproto.Message): + pass + + +@dataclass +class GetPreAvatarListScRsp(betterproto.Message): + jmjgmdhnpen: List["OPPGLJBHKLL"] = betterproto.message_field(7) + retcode: int = betterproto.uint32_field(3) + + +@dataclass +class PVEBattleResultCsReq(betterproto.Message): + is_ai_consider_ultra_skill: bool = betterproto.bool_field(2) + jcjfgojfege: int = betterproto.uint32_field(1) + stt: "BattleStatistics" = betterproto.message_field(7) + end_status: "BattleEndStatus" = betterproto.enum_field(5) + hpekekipjlf: Dict[str, int] = betterproto.map_field( + 6, betterproto.TYPE_STRING, betterproto.TYPE_UINT32 + ) + cost_time: int = betterproto.uint32_field(10) + stage_id: int = betterproto.uint32_field(13) + battle_id: int = betterproto.uint32_field(4) + op_list: List["BattleOp"] = betterproto.message_field(11) + turn_snapshot_hash: bytes = betterproto.bytes_field(8) + is_auto_fight: bool = betterproto.bool_field(15) + client_version: int = betterproto.uint32_field(9) + debug_extra_info: str = betterproto.string_field(12) + client_res_version: int = betterproto.uint32_field(3) + gjgkagfpagm: bool = betterproto.bool_field(14) + + +@dataclass +class PVEBattleResultScRsp(betterproto.Message): + event_id: int = betterproto.uint32_field(15) + klodelecmci: int = betterproto.uint32_field(2) + mismatch_turn_count: int = betterproto.uint32_field(14) + end_status: "BattleEndStatus" = betterproto.enum_field(8) + multiple_drop_data: "ItemList" = betterproto.message_field(1) + item_list_unk2: "ItemList" = betterproto.message_field(1637) + stage_id: int = betterproto.uint32_field(11) + check_identical: bool = betterproto.bool_field(9) + bin_version: str = betterproto.string_field(6) + drop_data: "ItemList" = betterproto.message_field(3) + battle_id: int = betterproto.uint32_field(5) + ggmpfnkofkd: int = betterproto.uint32_field(10) + res_version: str = betterproto.string_field(7) + retcode: int = betterproto.uint32_field(12) + battle_avatar_list: List["BattleAvatar"] = betterproto.message_field(4) + kjchgehdlno: "MBKOCMMICPG" = betterproto.message_field(1649) + item_list_unk1: "ItemList" = betterproto.message_field(13) + + +@dataclass +class QuitBattleCsReq(betterproto.Message): + stt: "BattleStatistics" = betterproto.message_field(1) + rebattle_type: "RebattleType" = betterproto.enum_field(7) + + +@dataclass +class QuitBattleScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(11) + + +@dataclass +class GetCurBattleInfoCsReq(betterproto.Message): + pass + + +@dataclass +class GetCurBattleInfoScRsp(betterproto.Message): + battle_info: "SceneBattleInfo" = betterproto.message_field(11) + pbphjbafgbb: "AetherDivideBattleInfo" = betterproto.message_field(7) + ibpjkffflng: int = betterproto.uint32_field(13) + last_end_status: "BattleEndStatus" = betterproto.enum_field(5) + retcode: int = betterproto.uint32_field(1) + + +@dataclass +class SyncClientResVersionCsReq(betterproto.Message): + client_res_version: int = betterproto.uint32_field(10) + + +@dataclass +class SyncClientResVersionScRsp(betterproto.Message): + client_res_version: int = betterproto.uint32_field(8) + retcode: int = betterproto.uint32_field(12) + + +@dataclass +class QuitBattleScNotify(betterproto.Message): + pass + + +@dataclass +class BattleLogReportCsReq(betterproto.Message): + pass + + +@dataclass +class BattleLogReportScRsp(betterproto.Message): + is_battle_log_report: bool = betterproto.bool_field(4) + retcode: int = betterproto.uint32_field(15) + + +@dataclass +class ServerSimulateBattleFinishScNotify(betterproto.Message): + pass + + +@dataclass +class ReBattleAfterBattleLoseCsNotify(betterproto.Message): + pmjahilblfl: bool = betterproto.bool_field(4) + + +@dataclass +class RebattleByClientCsNotify(betterproto.Message): + rebattle_type: "RebattleType" = betterproto.enum_field(8) + stt: "BattleStatistics" = betterproto.message_field(10) + + +@dataclass +class GetBattleCollegeDataCsReq(betterproto.Message): + pass + + +@dataclass +class GetBattleCollegeDataScRsp(betterproto.Message): + mamhojmfjof: int = betterproto.uint32_field(11) + retcode: int = betterproto.uint32_field(13) + finished_college_id_list: List[int] = betterproto.uint32_field(2) + + +@dataclass +class BattleCollegeDataChangeScNotify(betterproto.Message): + finished_college_id_list: List[int] = betterproto.uint32_field(12) + reward: "ItemList" = betterproto.message_field(14) + mamhojmfjof: int = betterproto.uint32_field(6) + + +@dataclass +class StartBattleCollegeCsReq(betterproto.Message): + id: int = betterproto.uint32_field(9) + + +@dataclass +class StartBattleCollegeScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(7) + battle_info: "SceneBattleInfo" = betterproto.message_field(2) + id: int = betterproto.uint32_field(6) + + +@dataclass +class BattlePassInfoNotify(betterproto.Message): + ljoekefkpko: int = betterproto.uint64_field(9) + exp: int = betterproto.uint32_field(4) + inbockjglbo: int = betterproto.uint64_field(2) + ljflflimkad: int = betterproto.uint32_field(13) + cphiiockhpi: int = betterproto.uint64_field(15) + nkaoknmholh: int = betterproto.uint64_field(7) + level: int = betterproto.uint32_field(6) + fdkkikganck: int = betterproto.uint64_field(8) + edbmnmdjbko: int = betterproto.uint32_field(5) + jllhalohjii: "BpTierType" = betterproto.enum_field(10) + hkeoaaccbpl: int = betterproto.uint64_field(1) + ekgopldjoii: int = betterproto.uint64_field(12) + cbjklleohdc: int = betterproto.uint64_field(11) + + +@dataclass +class TakeBpRewardCsReq(betterproto.Message): + type: "BpRewardType" = betterproto.enum_field(1) + level: int = betterproto.uint32_field(15) + optional_reward_id: int = betterproto.uint32_field(14) + + +@dataclass +class TakeBpRewardScRsp(betterproto.Message): + reward: "ItemList" = betterproto.message_field(11) + retcode: int = betterproto.uint32_field(8) + + +@dataclass +class BuyBpLevelCsReq(betterproto.Message): + ldnjeacfbje: int = betterproto.uint32_field(5) + + +@dataclass +class BuyBpLevelScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(7) + + +@dataclass +class OptionalReward(betterproto.Message): + optional_reward_id: int = betterproto.uint32_field(4) + level: int = betterproto.uint32_field(1) + + +@dataclass +class TakeAllRewardCsReq(betterproto.Message): + modoofjoiao: List["OptionalReward"] = betterproto.message_field(15) + + +@dataclass +class TakeAllRewardScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(11) + reward: "ItemList" = betterproto.message_field(5) + + +@dataclass +class GetBenefitActivityInfoCsReq(betterproto.Message): + pass + + +@dataclass +class LuckyKoiInfo(betterproto.Message): + uid_str: str = betterproto.string_field(10) + name_str: str = betterproto.string_field(3) + head_icon: int = betterproto.uint32_field(11) + + +@dataclass +class BenefitRewardItem(betterproto.Message): + level: int = betterproto.uint32_field(15) + item_list: "ItemList" = betterproto.message_field(10) + + +@dataclass +class BenefitItemConfig(betterproto.Message): + reveal_time: int = betterproto.uint64_field(5) + end_time: int = betterproto.uint64_field(14) + rogue_score_reward_info: List["BenefitRewardItem"] = betterproto.message_field(13) + lucky_koi_list: List["LuckyKoiInfo"] = betterproto.message_field(3) + reveal_num_limit: int = betterproto.uint32_field(7) + begin_time: int = betterproto.uint64_field(9) + + +@dataclass +class BenefitData(betterproto.Message): + config: "BenefitItemConfig" = betterproto.message_field(10) + level: int = betterproto.uint32_field(7) + daily_index: int = betterproto.uint32_field(14) + status: int = betterproto.uint32_field(4) + + +@dataclass +class GetBenefitActivityInfoScRsp(betterproto.Message): + benefit_data_list: List["BenefitData"] = betterproto.message_field(3) + retcode: int = betterproto.uint32_field(8) + is_open: bool = betterproto.bool_field(5) + + +@dataclass +class SwitchItem(betterproto.Message): + daily_index: int = betterproto.uint32_field(8) + einfbgkendh: bool = betterproto.bool_field(7) + + +@dataclass +class TakeBenefitActivityRewardCsReq(betterproto.Message): + bfbpcbnpfph: bool = betterproto.bool_field(7) + switch_list: List["SwitchItem"] = betterproto.message_field(6) + + +@dataclass +class RewardSwitchItem(betterproto.Message): + einfbgkendh: bool = betterproto.bool_field(8) + daily_index: int = betterproto.uint32_field(12) + item_list: "ItemList" = betterproto.message_field(2) + + +@dataclass +class TakeBenefitActivityRewardScRsp(betterproto.Message): + switch_list: List["RewardSwitchItem"] = betterproto.message_field(4) + ckekcconjgb: "ItemList" = betterproto.message_field(12) + retcode: int = betterproto.uint32_field(14) + + +@dataclass +class JoinBenefitActivityCsReq(betterproto.Message): + daily_index: int = betterproto.uint32_field(4) + + +@dataclass +class JoinBenefitActivityScRsp(betterproto.Message): + daily_index: int = betterproto.uint32_field(13) + retcode: int = betterproto.uint32_field(2) + + +@dataclass +class IJKJJDHLKLB(betterproto.Message): + avatar_id: int = betterproto.uint32_field(8) + avatar_type: "AvatarType" = betterproto.enum_field(15) + + +@dataclass +class FCIHIJLOMGA(betterproto.Message): + hjmglemjhkg: int = betterproto.uint32_field(13) + hnpeappmgaa: int = betterproto.uint32_field(3) + mdlachdkmph: List["IJKJJDHLKLB"] = betterproto.message_field(6) + cpgoipicpjf: int = betterproto.uint32_field(14) + llfofpndafg: int = betterproto.uint32_field(8) + hlibijfhhpg: List[int] = betterproto.uint32_field(9) + naalcbmbpgc: int = betterproto.uint32_field(2) + challenge_id: int = betterproto.uint32_field(15) + avatar_list: List[int] = betterproto.uint32_field(5) + aplknjegbkf: bool = betterproto.bool_field(1) + + +@dataclass +class GetBoxingClubInfoCsReq(betterproto.Message): + pass + + +@dataclass +class GetBoxingClubInfoScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(2) + challenge_list: List["FCIHIJLOMGA"] = betterproto.message_field(4) + + +@dataclass +class GNEIBBPOAAB(betterproto.Message): + avatar_type: "AvatarType" = betterproto.enum_field(3) + avatar_id: int = betterproto.uint32_field(12) + + +@dataclass +class MatchBoxingClubOpponentCsReq(betterproto.Message): + mdlachdkmph: List["GNEIBBPOAAB"] = betterproto.message_field(13) + avatar_list: List[int] = betterproto.uint32_field(11) + challenge_id: int = betterproto.uint32_field(12) + + +@dataclass +class MatchBoxingClubOpponentScRsp(betterproto.Message): + challenge: "FCIHIJLOMGA" = betterproto.message_field(3) + retcode: int = betterproto.uint32_field(8) + + +@dataclass +class ChooseBoxingClubResonanceCsReq(betterproto.Message): + llfofpndafg: int = betterproto.uint32_field(15) + challenge_id: int = betterproto.uint32_field(7) + + +@dataclass +class ChooseBoxingClubResonanceScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(6) + challenge: "FCIHIJLOMGA" = betterproto.message_field(4) + + +@dataclass +class SetBoxingClubResonanceLineupCsReq(betterproto.Message): + challenge_id: int = betterproto.uint32_field(12) + mdlachdkmph: List["GNEIBBPOAAB"] = betterproto.message_field(14) + + +@dataclass +class SetBoxingClubResonanceLineupScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(11) + challenge: "FCIHIJLOMGA" = betterproto.message_field(5) + + +@dataclass +class ChooseBoxingClubStageOptionalBuffCsReq(betterproto.Message): + fmgmaiegofp: int = betterproto.uint32_field(2) + challenge_id: int = betterproto.uint32_field(12) + + +@dataclass +class ChooseBoxingClubStageOptionalBuffScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(5) + challenge: "FCIHIJLOMGA" = betterproto.message_field(3) + + +@dataclass +class StartBoxingClubBattleCsReq(betterproto.Message): + challenge_id: int = betterproto.uint32_field(3) + + +@dataclass +class StartBoxingClubBattleScRsp(betterproto.Message): + challenge_id: int = betterproto.uint32_field(2) + retcode: int = betterproto.uint32_field(12) + battle_info: "SceneBattleInfo" = betterproto.message_field(6) + + +@dataclass +class GiveUpBoxingClubChallengeCsReq(betterproto.Message): + challenge_id: int = betterproto.uint32_field(2) + pcpdfjhdjcc: bool = betterproto.bool_field(4) + + +@dataclass +class GiveUpBoxingClubChallengeScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(4) + challenge: "FCIHIJLOMGA" = betterproto.message_field(11) + + +@dataclass +class BoxingClubRewardScNotify(betterproto.Message): + naalcbmbpgc: int = betterproto.uint32_field(1) + is_win: bool = betterproto.bool_field(3) + challenge_id: int = betterproto.uint32_field(12) + reward: "ItemList" = betterproto.message_field(9) + + +@dataclass +class BoxingClubChallengeUpdateScNotify(betterproto.Message): + challenge: "FCIHIJLOMGA" = betterproto.message_field(5) + + +@dataclass +class Challenge(betterproto.Message): + kfdaicilnmb: bool = betterproto.bool_field(7) + stage_info: "ChallengeStageInfo" = betterproto.message_field(12) + record_id: int = betterproto.uint32_field(4) + score_id: int = betterproto.uint32_field(15) + star: int = betterproto.uint32_field(11) + score_two: int = betterproto.uint32_field(8) + taken_reward: int = betterproto.uint32_field(10) + challenge_id: int = betterproto.uint32_field(2) + + +@dataclass +class ChallengeGroup(betterproto.Message): + taken_stars_count_reward: int = betterproto.uint64_field(15) + group_id: int = betterproto.uint32_field(13) + + +@dataclass +class ChallengeHistoryMaxLevel(betterproto.Message): + reward_display_type: int = betterproto.uint32_field(3) + level: int = betterproto.uint32_field(7) + + +@dataclass +class GetChallengeCsReq(betterproto.Message): + pass + + +@dataclass +class GetChallengeScRsp(betterproto.Message): + challenge_group_list: List["ChallengeGroup"] = betterproto.message_field(11) + lpljmkpblif: int = betterproto.uint32_field(4) + challenge_list: List["Challenge"] = betterproto.message_field(10) + max_level_list: List["ChallengeHistoryMaxLevel"] = betterproto.message_field(5) + retcode: int = betterproto.uint32_field(1) + + +@dataclass +class ChallengeStoryBuffInfo(betterproto.Message): + buff_two: int = betterproto.uint32_field(1) + buff_one: int = betterproto.uint32_field(14) + + +@dataclass +class ChallengeBossBuffInfo(betterproto.Message): + buff_one: int = betterproto.uint32_field(3) + buff_two: int = betterproto.uint32_field(11) + + +@dataclass +class ChallengeBuffInfo(betterproto.Message): + story_info: "ChallengeStoryBuffInfo" = betterproto.message_field( + 13 + ) + boss_info: "ChallengeBossBuffInfo" = betterproto.message_field(4) + + +@dataclass +class StartChallengeCsReq(betterproto.Message): + first_lineup: List[int] = betterproto.uint32_field(1) + second_lineup: List[int] = betterproto.uint32_field(6) + challenge_id: int = betterproto.uint32_field(5) + stage_info: "ChallengeBuffInfo" = betterproto.message_field(10) + + +@dataclass +class StartChallengeScRsp(betterproto.Message): + stage_info: "ChallengeStageInfo" = betterproto.message_field(9) + scene: "SceneInfo" = betterproto.message_field(13) + lineup_list: List["LineupInfo"] = betterproto.message_field(10) + retcode: int = betterproto.uint32_field(15) + cur_challenge: "CurChallenge" = betterproto.message_field(11) + + +@dataclass +class StartPartialChallengeCsReq(betterproto.Message): + is_first_half: bool = betterproto.bool_field(3) + challenge_id: int = betterproto.uint32_field(10) + buff_id: int = betterproto.uint32_field(8) + + +@dataclass +class StartPartialChallengeScRsp(betterproto.Message): + cur_challenge: "CurChallenge" = betterproto.message_field(4) + scene: "SceneInfo" = betterproto.message_field(8) + retcode: int = betterproto.uint32_field(12) + lineup: "LineupInfo" = betterproto.message_field(14) + + +@dataclass +class LeaveChallengeCsReq(betterproto.Message): + pass + + +@dataclass +class LeaveChallengeScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(3) + + +@dataclass +class ChallengeSettleNotify(betterproto.Message): + challenge_score: int = betterproto.uint32_field(3) + cur_challenge: "CurChallenge" = betterproto.message_field(4) + score_two: int = betterproto.uint32_field(10) + hahaeifmlbm: List[int] = betterproto.uint32_field(14) + challenge_id: int = betterproto.uint32_field(5) + lpljmkpblif: int = betterproto.uint32_field(12) + star: int = betterproto.uint32_field(11) + max_level: "ChallengeHistoryMaxLevel" = betterproto.message_field(6) + is_win: bool = betterproto.bool_field(8) + reward: "ItemList" = betterproto.message_field(15) + + +@dataclass +class KillMonster(betterproto.Message): + kill_num: int = betterproto.uint32_field(1) + monster_id: int = betterproto.uint32_field(13) + + +@dataclass +class ChallengeStoryBuffList(betterproto.Message): + buff_list: List[int] = betterproto.uint32_field(14) + + +@dataclass +class ChallengeBossBuffList(betterproto.Message): + buff_list: List[int] = betterproto.uint32_field(5) + challenge_boss_const: int = betterproto.uint32_field(10) + + +@dataclass +class ChallengeCurBuffInfo(betterproto.Message): + cur_story_buffs: "ChallengeStoryBuffList" = betterproto.message_field( + 6 + ) + cur_boss_buffs: "ChallengeBossBuffList" = betterproto.message_field( + 2 + ) + + +@dataclass +class CurChallenge(betterproto.Message): + status: "ChallengeStatus" = betterproto.enum_field(10) + round_count: int = betterproto.uint32_field(9) + stage_info: "ChallengeCurBuffInfo" = betterproto.message_field(2) + dead_avatar_num: int = betterproto.uint32_field(1) + extra_lineup_type: "ExtraLineupType" = betterproto.enum_field(5) + challenge_id: int = betterproto.uint32_field(8) + kill_monster_list: List["KillMonster"] = betterproto.message_field(15) + score_two: int = betterproto.uint32_field(14) + score_id: int = betterproto.uint32_field(13) + + +@dataclass +class GetCurChallengeCsReq(betterproto.Message): + pass + + +@dataclass +class GetCurChallengeScRsp(betterproto.Message): + lineup_list: List["LineupInfo"] = betterproto.message_field(1) + retcode: int = betterproto.uint32_field(15) + cur_challenge: "CurChallenge" = betterproto.message_field(12) + + +@dataclass +class ChallengeLineupNotify(betterproto.Message): + extra_lineup_type: "ExtraLineupType" = betterproto.enum_field(11) + + +@dataclass +class TakeChallengeRewardCsReq(betterproto.Message): + group_id: int = betterproto.uint32_field(13) + + +@dataclass +class TakeChallengeRewardScRsp(betterproto.Message): + taken_reward_list: List["TakenChallengeRewardInfo"] = betterproto.message_field(14) + group_id: int = betterproto.uint32_field(11) + retcode: int = betterproto.uint32_field(15) + + +@dataclass +class TakenChallengeRewardInfo(betterproto.Message): + star_count: int = betterproto.uint32_field(8) + reward: "ItemList" = betterproto.message_field(6) + + +@dataclass +class ChallengeStatistics(betterproto.Message): + record_id: int = betterproto.uint32_field(9) + stage_tertinggi: "ChallengeStageTertinggi" = betterproto.message_field(8) + + +@dataclass +class ChallengeStoryStatistics(betterproto.Message): + record_id: int = betterproto.uint32_field(1) + stage_tertinggi: "ChallengeStoryStageTertinggi" = betterproto.message_field(10) + + +@dataclass +class ChallengeBossStatistics(betterproto.Message): + record_id: int = betterproto.uint32_field(9) + stage_tertinggi: "ChallengeBossStageTertinggi" = betterproto.message_field(7) + + +@dataclass +class ChallengeStageTertinggi(betterproto.Message): + round_count: int = betterproto.uint32_field(6) + inhddnnpbdb: int = betterproto.uint32_field(11) + lineup_list: List["ChallengeLineupList"] = betterproto.message_field(1) + level: int = betterproto.uint32_field(12) + + +@dataclass +class ChallengeStoryStageTertinggi(betterproto.Message): + buff_two: int = betterproto.uint32_field(6) + buff_one: int = betterproto.uint32_field(1) + level: int = betterproto.uint32_field(7) + score_id: int = betterproto.uint32_field(8) + lineup_list: List["ChallengeLineupList"] = betterproto.message_field(3) + inhddnnpbdb: int = betterproto.uint32_field(2) + + +@dataclass +class ChallengeBossStageTertinggi(betterproto.Message): + lineup_list: List["ChallengeLineupList"] = betterproto.message_field(10) + level: int = betterproto.uint32_field(3) + score_id: int = betterproto.uint32_field(15) + inhddnnpbdb: int = betterproto.uint32_field(4) + buff_one: int = betterproto.uint32_field(1) + buff_two: int = betterproto.uint32_field(6) + + +@dataclass +class ChallengeLineupList(betterproto.Message): + avatar_list: List["ChallengeAvatarInfo"] = betterproto.message_field(14) + + +@dataclass +class ChallengeAvatarInfo(betterproto.Message): + ggdiibcdobb: int = betterproto.uint32_field(7) + level: int = betterproto.uint32_field(13) + id: int = betterproto.uint32_field(4) + avatar_type: "AvatarType" = betterproto.enum_field(10) + index: int = betterproto.uint32_field(6) + + +@dataclass +class GetChallengeGroupStatisticsCsReq(betterproto.Message): + group_id: int = betterproto.uint32_field(2) + + +@dataclass +class GetChallengeGroupStatisticsScRsp(betterproto.Message): + challenge_default: "ChallengeStatistics" = betterproto.message_field( + 2 + ) + challenge_story: "ChallengeStoryStatistics" = betterproto.message_field( + 8 + ) + challenge_boss: "ChallengeBossStatistics" = betterproto.message_field( + 13 + ) + retcode: int = betterproto.uint32_field(1) + group_id: int = betterproto.uint32_field(15) + + +@dataclass +class ChallengeBossSingleNodeInfo(betterproto.Message): + buff_id: int = betterproto.uint32_field(9) + max_score: int = betterproto.uint32_field(13) + is_win: bool = betterproto.bool_field(11) + meelgndnomn: bool = betterproto.bool_field(7) + + +@dataclass +class ChallengeBossEquipmentInfo(betterproto.Message): + level: int = betterproto.uint32_field(7) + unique_id: int = betterproto.uint32_field(2) + rank: int = betterproto.uint32_field(10) + tid: int = betterproto.uint32_field(6) + promotion: int = betterproto.uint32_field(12) + + +@dataclass +class ChallengeBossRelicInfo(betterproto.Message): + sub_affix_list: List["RelicAffix"] = betterproto.message_field(11) + level: int = betterproto.uint32_field(13) + unique_id: int = betterproto.uint32_field(12) + main_affix_id: int = betterproto.uint32_field(7) + tid: int = betterproto.uint32_field(6) + + +@dataclass +class ChallengeBossAvatarRelicInfo(betterproto.Message): + avatar_relic_slot_map: Dict[int, "ChallengeBossRelicInfo"] = betterproto.map_field( + 10, betterproto.TYPE_UINT32, betterproto.TYPE_MESSAGE + ) + + +@dataclass +class ChallengeBossInfo(betterproto.Message): + ncbdnpgpeai: bool = betterproto.bool_field(4) + second_node: "ChallengeBossSingleNodeInfo" = betterproto.message_field(2) + second_lineup: List[int] = betterproto.uint32_field(13) + first_lineup: List[int] = betterproto.uint32_field(5) + challenge_avatar_equipment_map: Dict[int, "ChallengeBossEquipmentInfo"] = ( + betterproto.map_field(12, betterproto.TYPE_UINT32, betterproto.TYPE_MESSAGE) + ) + first_node: "ChallengeBossSingleNodeInfo" = betterproto.message_field(8) + challenge_avatar_relic_map: Dict[int, "ChallengeBossAvatarRelicInfo"] = ( + betterproto.map_field(10, betterproto.TYPE_UINT32, betterproto.TYPE_MESSAGE) + ) + + +@dataclass +class ChallengeStageInfo(betterproto.Message): + boss_info: "ChallengeBossInfo" = betterproto.message_field(4) + + +@dataclass +class RestartChallengePhaseCsReq(betterproto.Message): + pass + + +@dataclass +class RestartChallengePhaseScRsp(betterproto.Message): + scene: "SceneInfo" = betterproto.message_field(4) + retcode: int = betterproto.uint32_field(14) + + +@dataclass +class EnterChallengeNextPhaseCsReq(betterproto.Message): + pass + + +@dataclass +class EnterChallengeNextPhaseScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(8) + scene: "SceneInfo" = betterproto.message_field(10) + + +@dataclass +class ChallengeBossPhaseSettleNotify(betterproto.Message): + page_type: int = betterproto.uint32_field(5) + phase: int = betterproto.uint32_field(2) + score_two: int = betterproto.uint32_field(13) + battle_target_list: List["BattleTarget"] = betterproto.message_field(9) + star: int = betterproto.uint32_field(7) + challenge_score: int = betterproto.uint32_field(10) + challenge_id: int = betterproto.uint32_field(15) + is_win: bool = betterproto.bool_field(6) + is_reward: bool = betterproto.bool_field(8) + is_second_half: bool = betterproto.bool_field(3) + + +@dataclass +class SendMsgCsReq(betterproto.Message): + message_text: str = betterproto.string_field(6) + chat_type: "ChatType" = betterproto.enum_field(13) + message_type: "MsgType" = betterproto.enum_field(3) + hnbepabnbng: "PEDLPHDBNAF" = betterproto.message_field(9) + extra_id: int = betterproto.uint32_field(8) + target_list: List[int] = betterproto.uint32_field(5) + + +@dataclass +class SendMsgScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(3) + end_time: int = betterproto.uint64_field(1) + + +@dataclass +class ChatMessageData(betterproto.Message): + message_type: "MsgType" = betterproto.enum_field(6) + sender_id: int = betterproto.uint32_field(1) + content: str = betterproto.string_field(15) + create_time: int = betterproto.uint64_field(11) + hnbepabnbng: "PEDLPHDBNAF" = betterproto.message_field(5) + extra_id: int = betterproto.uint32_field(14) + + +@dataclass +class RevcMsgScNotify(betterproto.Message): + message_text: str = betterproto.string_field(12) + hnbepabnbng: "PEDLPHDBNAF" = betterproto.message_field(7) + extra_id: int = betterproto.uint32_field(4) + message_type: "MsgType" = betterproto.enum_field(10) + target_uid: int = betterproto.uint32_field(14) + source_uid: int = betterproto.uint32_field(1) + chat_type: "ChatType" = betterproto.enum_field(3) + + +@dataclass +class PrivateMsgOfflineUsersScNotify(betterproto.Message): + contact_id_list: List[int] = betterproto.uint32_field(2) + + +@dataclass +class GetPrivateChatHistoryCsReq(betterproto.Message): + contact_side: int = betterproto.uint32_field(6) + target_side: int = betterproto.uint32_field(4) + + +@dataclass +class GetPrivateChatHistoryScRsp(betterproto.Message): + chat_message_list: List["ChatMessageData"] = betterproto.message_field(15) + target_side: int = betterproto.uint32_field(9) + retcode: int = betterproto.uint32_field(6) + contact_side: int = betterproto.uint32_field(14) + + +@dataclass +class FriendHistoryInfo(betterproto.Message): + last_send_time: int = betterproto.int64_field(10) + contact_side: int = betterproto.uint32_field(2) + + +@dataclass +class GetChatFriendHistoryCsReq(betterproto.Message): + pass + + +@dataclass +class GetChatFriendHistoryScRsp(betterproto.Message): + friend_history_info: List["FriendHistoryInfo"] = betterproto.message_field(9) + retcode: int = betterproto.uint32_field(3) + + +@dataclass +class GetChatEmojiListCsReq(betterproto.Message): + pass + + +@dataclass +class GetChatEmojiListScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(12) + chat_emoji_list: List[int] = betterproto.uint32_field(15) + + +@dataclass +class MarkChatEmojiCsReq(betterproto.Message): + is_remove_id: bool = betterproto.bool_field(3) + extra_id: int = betterproto.uint32_field(8) + + +@dataclass +class MarkChatEmojiScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(6) + is_remove_id: bool = betterproto.bool_field(3) + extra_id: int = betterproto.uint32_field(2) + + +@dataclass +class BatchMarkChatEmojiCsReq(betterproto.Message): + marked_emoji_id_list: List[int] = betterproto.uint32_field(7) + + +@dataclass +class BatchMarkChatEmojiScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(8) + marked_emoji_id_list: List[int] = betterproto.uint32_field(1) + + +@dataclass +class GetLoginChatInfoCsReq(betterproto.Message): + pass + + +@dataclass +class GetLoginChatInfoScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(5) + contact_id_list: List[int] = betterproto.uint32_field(1) + + +@dataclass +class RogueAvatarReviveCost(betterproto.Message): + rogue_revive_cost: "ItemCostData" = betterproto.message_field(12) + + +@dataclass +class ChessRogueInfo(betterproto.Message): + scene: "SceneInfo" = betterproto.message_field(5) + lineup: "LineupInfo" = betterproto.message_field(13) + + +@dataclass +class ChessRogueDiceInfo(betterproto.Message): + ngdedlkngfg: List[int] = betterproto.uint32_field(1708) + display_id: int = betterproto.uint32_field(5) + dice: "ChessRogueDice" = betterproto.message_field(1702) + game_dice_branch_id: int = betterproto.uint32_field(14) + cheat_times: int = betterproto.uint32_field(4) + fneidjimjph: bool = betterproto.bool_field(263) + dice_type: "ChessRogueDiceType" = betterproto.enum_field(7) + jfipiifpmmb: int = betterproto.int32_field(1591) + cur_surface_id: int = betterproto.uint32_field(9) + game_branch_id: int = betterproto.uint32_field(12) + pagpblafneh: int = betterproto.uint32_field(11) + reroll_times: int = betterproto.uint32_field(8) + can_reroll_dice: bool = betterproto.bool_field(6) + dice_status: "ChessRogueDiceStatus" = betterproto.enum_field(3) + edphldegjlm: "EENDHPKPFLP" = betterproto.message_field(1462) + rogue_modifider: "RogueModifier" = betterproto.message_field(139) + cur_surface_slot_id: int = betterproto.uint32_field(1) + + +@dataclass +class ChessRogueRollDiceCsReq(betterproto.Message): + kchfjdajecm: int = betterproto.uint32_field(9) + + +@dataclass +class ChessRogueRollDiceScRsp(betterproto.Message): + rogue_dice_info: "ChessRogueDiceInfo" = betterproto.message_field(6) + retcode: int = betterproto.uint32_field(5) + + +@dataclass +class CellMonster(betterproto.Message): + monster_id: int = betterproto.uint32_field(13) + boss_decay_id: int = betterproto.uint32_field(6) + + +@dataclass +class CellMonsterInfo(betterproto.Message): + cell_monster_list: List["CellMonster"] = betterproto.message_field(6) + confirm: bool = betterproto.bool_field(3) + select_boss_id: int = betterproto.uint32_field(5) + + +@dataclass +class CellMonsterSelectInfo(betterproto.Message): + select_decay_id: List[int] = betterproto.uint32_field(12) + + +@dataclass +class CellFinalMonsterInfo(betterproto.Message): + cell_boss_info: "CellMonsterInfo" = betterproto.message_field(5) + select_boss_info: "CellMonsterSelectInfo" = betterproto.message_field(1) + + +@dataclass +class CellAdvanceInfo(betterproto.Message): + cell_boss_info: "CellMonsterInfo" = betterproto.message_field( + 9 + ) + select_boss_info: "CellMonsterSelectInfo" = betterproto.message_field( + 14 + ) + final_boss_info: "CellFinalMonsterInfo" = betterproto.message_field( + 1 + ) + + +@dataclass +class ChessRogueCell(betterproto.Message): + is_unlocked: bool = betterproto.bool_field(8) + unlock: bool = betterproto.bool_field(15) + stage_info: "CellAdvanceInfo" = betterproto.message_field(14) + block_type: int = betterproto.uint32_field(3) + id: int = betterproto.uint32_field(10) + room_id: int = betterproto.uint32_field(12) + pos_y: int = betterproto.uint32_field(2) + pos_x: int = betterproto.uint32_field(13) + special_type: "ChessRogueCellSpecialType" = betterproto.enum_field(11) + mark_type: int = betterproto.uint32_field(7) + cell_status: "ChessRogueBoardCellStatus" = betterproto.enum_field(6) + + +@dataclass +class CellInfo(betterproto.Message): + hdhiongofid: int = betterproto.uint32_field(4) + cell_list: List["ChessRogueCell"] = betterproto.message_field(8) + hlamiclgpee: int = betterproto.uint32_field(15) + bmajdilbpob: int = betterproto.uint32_field(6) + nghppegbpao: int = betterproto.uint32_field(12) + + +@dataclass +class ChessRogueHistoryCellInfo(betterproto.Message): + cell_id: int = betterproto.uint32_field(12) + room_id: int = betterproto.uint32_field(5) + + +@dataclass +class KKCKGEOJFKE(betterproto.Message): + bdmlgepndfm: int = betterproto.uint32_field(10) + bohdminejno: "EENDHPKPFLP" = betterproto.message_field(14) + + +@dataclass +class ChessRogueAreaInfo(betterproto.Message): + allow_select_cell_id_list: List[int] = betterproto.uint32_field(5) + history_cell: List["ChessRogueHistoryCellInfo"] = betterproto.message_field(2) + cell: "CellInfo" = betterproto.message_field(1) + cfekaolkhjg: "KKCKGEOJFKE" = betterproto.message_field(14) + cur_board_id: int = betterproto.uint32_field(8) + cur_id: int = betterproto.uint32_field(4) + layer_status: "ChessRogueBoardCellStatus" = betterproto.enum_field(13) + + +@dataclass +class ChessRogueLevelInfo(betterproto.Message): + ocdnmhnnkgm: int = betterproto.int32_field(10) + area_info: "ChessRogueAreaInfo" = betterproto.message_field(4) + action_point: int = betterproto.int32_field(14) + layer_id: int = betterproto.uint32_field(11) + area_id_list: List[int] = betterproto.uint32_field(1) + id: int = betterproto.uint32_field(3) + level_status: int = betterproto.uint32_field(7) + mhoijafgecp: int = betterproto.uint32_field(9) + + +@dataclass +class ChessRogueQueryAeon(betterproto.Message): + aeon_id: int = betterproto.uint32_field(12) + mamhojmfjof: int = betterproto.uint32_field(14) + + +@dataclass +class ChessRogueQueryAeonInfo(betterproto.Message): + aeon_list: List["ChessRogueQueryAeon"] = betterproto.message_field(5) + + +@dataclass +class ChessRogueAeonInfo(betterproto.Message): + chess_aeon_info: "ChessRogueQueryAeonInfo" = betterproto.message_field(14) + icjabpgmacj: int = betterproto.int32_field(13) + game_aeon_id: int = betterproto.uint32_field(12) + aeon_id_list: List[int] = betterproto.uint32_field(5) + bohdminejno: "EENDHPKPFLP" = betterproto.message_field(10) + + +@dataclass +class ChessRogueLineupAvatarInfo(betterproto.Message): + avatar_id: int = betterproto.uint32_field(6) + + +@dataclass +class ChessRogueLineupInfo(betterproto.Message): + chess_avatar_list: List["ChessRogueLineupAvatarInfo"] = betterproto.message_field(2) + revive_info: "RogueAvatarReviveCost" = betterproto.message_field(6) + + +@dataclass +class HKMLALBDPGO(betterproto.Message): + lhcbbgimmdg: int = betterproto.uint32_field(1) + fahihdjfohm: int = betterproto.uint32_field(3) + boonpdeobla: List[int] = betterproto.uint32_field(2) + fjkgkaekbkj: bool = betterproto.bool_field(12) + + +@dataclass +class ChessRogueNousValueInfo(betterproto.Message): + nous_value: int = betterproto.int32_field(11) + + +@dataclass +class ChessRogueCurrentDifficultyInfo(betterproto.Message): + difficulty_id_list: List[int] = betterproto.uint32_field(10) + + +@dataclass +class ChessRogueGameInfo(betterproto.Message): + rogue_aeon_info: "ChessRogueAeonInfo" = betterproto.message_field(4) + level_info: "ChessRogueLevelInfo" = betterproto.message_field(8) + rogue_dice_info: "ChessRogueDiceInfo" = betterproto.message_field(2) + virtual_item_info: "RogueVirtualItem" = betterproto.message_field(10) + opakjjmagph: "IMNPEAJAJJO" = betterproto.message_field(3) + nous_value_info: "ChessRogueNousValueInfo" = betterproto.message_field(9) + pending_action: "RogueCommonPendingAction" = betterproto.message_field(15) + story_info: "HKMLALBDPGO" = betterproto.message_field(5) + rogue_buff_info: "ChessRogueBuffInfo" = betterproto.message_field(14) + rogue_lineup_info: "ChessRogueLineupInfo" = betterproto.message_field(11) + rogue_difficulty_info: "ChessRogueCurrentDifficultyInfo" = ( + betterproto.message_field(1724) + ) + rogue_sub_mode: int = betterproto.uint32_field(1) + game_miracle_info: "ChessRogueMiracleInfo" = betterproto.message_field(12) + rogue_current_game_info: List["RogueGameInfo"] = betterproto.message_field(7) + + +@dataclass +class ChessRogueQueryInfo(betterproto.Message): + query_dice_info: "ChessRogueQueryDiceInfo" = betterproto.message_field(9) + talent_info_list: "ChessRogueTalentInfo" = betterproto.message_field(1) + rogue_difficulty_info: "ChessRogueQueryDiffcultyInfo" = betterproto.message_field( + 13 + ) + area_id_list: List[int] = betterproto.uint32_field(5) + chess_aeon_info: "ChessRogueQueryAeonInfo" = betterproto.message_field(2) + explored_area_id_list: List[int] = betterproto.uint32_field(6) + + +@dataclass +class ChessRogueCurrentInfo(betterproto.Message): + rogue_current_game_info: List["RogueGameInfo"] = betterproto.message_field(14) + rogue_sub_mode: int = betterproto.uint32_field(3) + + +@dataclass +class ChessRogueGetInfo(betterproto.Message): + chess_aeon_info: "ChessRogueQueryAeonInfo" = betterproto.message_field(15) + talent_info_list: "ChessRogueTalentInfo" = betterproto.message_field(11) + rogue_difficulty_info: "ChessRogueQueryDiffcultyInfo" = betterproto.message_field( + 13 + ) + explored_area_id_list: List[int] = betterproto.uint32_field(3) + area_id_list: List[int] = betterproto.uint32_field(9) + query_dice_info: "ChessRogueQueryDiceInfo" = betterproto.message_field(6) + + +@dataclass +class ChessRogueFinishInfo(betterproto.Message): + egpcibjiajd: int = betterproto.uint32_field(320) + rogue_lineup: "LineupInfo" = betterproto.message_field(3) + dmbdnaicpfb: int = betterproto.uint32_field(1) + chess_rogue_main_story_id: int = betterproto.uint32_field(10) + plbcdiaadkd: int = betterproto.uint32_field(14) + rogue_sub_mode: int = betterproto.uint32_field(1004) + opakjjmagph: "IMNPEAJAJJO" = betterproto.message_field(1807) + quit_reason: "ChessRogueQuitReason" = betterproto.enum_field(4) + bgpeckfdeld: "ItemList" = betterproto.message_field(7) + opoimhhafjo: int = betterproto.uint32_field(1841) + is_finish: bool = betterproto.bool_field(5) + abehkcjhceh: int = betterproto.uint32_field(2016) + blbbokogfda: int = betterproto.uint32_field(8) + difficulty_level: int = betterproto.uint32_field(2) + rogue_buff_info: "ChessRogueBuff" = betterproto.message_field(12) + ipojmmgoopj: int = betterproto.uint32_field(9) + score_id: int = betterproto.uint32_field(811) + ojggmoopgil: List[int] = betterproto.uint32_field(13) + game_miracle_info: "ChessRogueMiracle" = betterproto.message_field(6) + + +@dataclass +class OJLEEFJELAP(betterproto.Message): + cell_list: List["ChessRogueCell"] = betterproto.message_field(3) + hbcmgiicjmk: int = betterproto.uint32_field(9) + + +@dataclass +class LAHJPFOOHEB(betterproto.Message): + kenpckfonok: int = betterproto.uint32_field(13) + chess_rogue_main_story_id: int = betterproto.uint32_field(10) + + +@dataclass +class DIPMFOMGCGL(betterproto.Message): + fahihdjfohm: int = betterproto.uint32_field(6) + cfibpmkaino: int = betterproto.uint32_field(5) + + +@dataclass +class ChessRogueQueryCsReq(betterproto.Message): + pass + + +@dataclass +class ChessRogueQueryScRsp(betterproto.Message): + hndlhicdnpc: "ChessRogueGameInfo" = betterproto.message_field(1) + query_info: "ChessRogueQueryInfo" = betterproto.message_field(10) + boikablfkec: "ChessRogueFinishInfo" = betterproto.message_field(15) + retcode: int = betterproto.uint32_field(3) + rogue_get_info: "ChessRogueGetInfo" = betterproto.message_field(14) + + +@dataclass +class ChessRogueEnterCellCsReq(betterproto.Message): + femgpnlfagc: int = betterproto.uint32_field(11) + cell_id: int = betterproto.uint32_field(4) + + +@dataclass +class ChessRogueEnterCellScRsp(betterproto.Message): + stage_info: "ChessRogueInfo" = betterproto.message_field(7) + retcode: int = betterproto.uint32_field(2) + cell_id: int = betterproto.uint32_field(3) + hndlhicdnpc: "ChessRogueGameInfo" = betterproto.message_field(8) + + +@dataclass +class ChessRogueEnterCsReq(betterproto.Message): + id: int = betterproto.uint32_field(15) + + +@dataclass +class ChessRogueEnterScRsp(betterproto.Message): + stage_info: "ChessRogueInfo" = betterproto.message_field(6) + retcode: int = betterproto.uint32_field(13) + id: int = betterproto.uint32_field(5) + hndlhicdnpc: "ChessRogueGameInfo" = betterproto.message_field(2) + + +@dataclass +class ChessRogueLeaveCsReq(betterproto.Message): + pass + + +@dataclass +class ChessRogueLeaveScRsp(betterproto.Message): + stage_info: "ChessRogueInfo" = betterproto.message_field(3) + retcode: int = betterproto.uint32_field(12) + query_info: "ChessRogueQueryInfo" = betterproto.message_field(13) + rogue_aeon_info: "ChessRogueAeonInfo" = betterproto.message_field(4) + rogue_get_info: "ChessRogueGetInfo" = betterproto.message_field(5) + + +@dataclass +class ChessRogueGiveUpCsReq(betterproto.Message): + pass + + +@dataclass +class ChessRogueGiveUpScRsp(betterproto.Message): + rogue_get_info: "ChessRogueGetInfo" = betterproto.message_field(5) + rogue_aeon_info: "ChessRogueAeonInfo" = betterproto.message_field(2) + query_info: "ChessRogueQueryInfo" = betterproto.message_field(10) + stage_info: "ChessRogueInfo" = betterproto.message_field(14) + boikablfkec: "ChessRogueFinishInfo" = betterproto.message_field(13) + retcode: int = betterproto.uint32_field(7) + + +@dataclass +class ChessRogueStartCsReq(betterproto.Message): + aeon_id: int = betterproto.uint32_field(3) + branch_id: int = betterproto.uint32_field(7) + base_avatar_id_list: List[int] = betterproto.uint32_field(6) + start_difficulty_id_list: List[int] = betterproto.uint32_field(4) + trial_avatar_id_list: List[int] = betterproto.uint32_field(14) + hjgndhlmmib: List[int] = betterproto.uint32_field(5) + id: int = betterproto.uint32_field(8) + + +@dataclass +class ChessRogueStartScRsp(betterproto.Message): + hndlhicdnpc: "ChessRogueGameInfo" = betterproto.message_field(7) + stage_info: "ChessRogueInfo" = betterproto.message_field(8) + dbdgahblgbb: "OJLEEFJELAP" = betterproto.message_field(9) + retcode: int = betterproto.uint32_field(6) + + +@dataclass +class ChessRogueQueryAeonDimensionsCsReq(betterproto.Message): + pass + + +@dataclass +class ChessRogueQueryAeonDimensionsScRsp(betterproto.Message): + hndlhicdnpc: "ChessRogueQueryAeonInfo" = betterproto.message_field(3) + retcode: int = betterproto.uint32_field(15) + + +@dataclass +class ChessRogueChangeyAeonDimensionNotify(betterproto.Message): + hndlhicdnpc: "ChessRogueQueryAeon" = betterproto.message_field(14) + + +@dataclass +class ChessRogueSelectCellCsReq(betterproto.Message): + femgpnlfagc: int = betterproto.uint32_field(6) + cell_id: int = betterproto.uint32_field(11) + + +@dataclass +class ChessRogueSelectCellScRsp(betterproto.Message): + femgpnlfagc: int = betterproto.uint32_field(2) + retcode: int = betterproto.uint32_field(7) + cell_id: int = betterproto.uint32_field(11) + kajafnpekaj: "OIAOLBGOAAG" = betterproto.message_field(8) + + +@dataclass +class ChessRogueLayerAccountInfoNotify(betterproto.Message): + difficulty_level: int = betterproto.uint32_field(4) + boikablfkec: "ChessRogueFinishInfo" = betterproto.message_field(8) + layer_id: int = betterproto.uint32_field(9) + + +@dataclass +class GetChessRogueBuffEnhanceInfoCsReq(betterproto.Message): + pass + + +@dataclass +class GetChessRogueBuffEnhanceInfoScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(3) + fhlomgdanjm: "ChessRogueBuffEnhanceList" = betterproto.message_field(9) + + +@dataclass +class EnhanceChessRogueBuffCsReq(betterproto.Message): + maze_buff_id: int = betterproto.uint32_field(2) + + +@dataclass +class EnhanceChessRogueBuffScRsp(betterproto.Message): + fhlomgdanjm: "ChessRogueBuffEnhanceList" = betterproto.message_field(3) + anagcoddmom: "RogueCommonBuff" = betterproto.message_field(10) + retcode: int = betterproto.uint32_field(6) + fgefcefkhmh: bool = betterproto.bool_field(4) + + +@dataclass +class ChessRoguePickAvatarCsReq(betterproto.Message): + prop_entity_id: int = betterproto.uint32_field(14) + base_avatar_id_list: List[int] = betterproto.uint32_field(9) + + +@dataclass +class ChessRoguePickAvatarScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(2) + rogue_lineup_info: "ChessRogueLineupInfo" = betterproto.message_field(10) + base_avatar_id_list: List[int] = betterproto.uint32_field(5) + + +@dataclass +class ChessRogueReviveAvatarCsReq(betterproto.Message): + interacted_prop_entity_id: int = betterproto.uint32_field(6) + base_avatar_id_list: List[int] = betterproto.uint32_field(14) + + +@dataclass +class ChessRogueReviveAvatarScRsp(betterproto.Message): + revive_info: "RogueAvatarReviveCost" = betterproto.message_field(15) + base_avatar_id_list: List[int] = betterproto.uint32_field(14) + retcode: int = betterproto.uint32_field(8) + + +@dataclass +class ChessRogueUpdateReviveInfoScNotify(betterproto.Message): + revive_info: "RogueAvatarReviveCost" = betterproto.message_field(2) + + +@dataclass +class ChessRogueUpdateMoneyInfoScNotify(betterproto.Message): + virtual_item_info: "RogueVirtualItem" = betterproto.message_field(15) + + +@dataclass +class ChessRogueUpdateDiceInfoScNotify(betterproto.Message): + rogue_dice_info: "ChessRogueDiceInfo" = betterproto.message_field(5) + + +@dataclass +class ChessRogueUpdateLevelBaseInfoScNotify(betterproto.Message): + level_status: "ChessRogueLevelStatus" = betterproto.enum_field(13) + reason: "ChessRogueUpdateLevelStatus" = betterproto.enum_field(15) + + +@dataclass +class ChessRogueUpdateAllowedSelectCellScNotify(betterproto.Message): + eamgahffeco: int = betterproto.uint32_field(6) + allow_select_cell_id_list: List[int] = betterproto.uint32_field(10) + + +@dataclass +class ChessRogueUpdateBoardScNotify(betterproto.Message): + dhdknmfmgbc: "CellInfo" = betterproto.message_field(11) + + +@dataclass +class ChessRogueUpdateAeonModifierValueScNotify(betterproto.Message): + aeon_id: int = betterproto.uint32_field(13) + icjabpgmacj: int = betterproto.int32_field(6) + + +@dataclass +class ChessRogueUpdateDicePassiveAccumulateValueScNotify(betterproto.Message): + cblaememmig: int = betterproto.int32_field(4) + + +@dataclass +class ChessRogueSkipTeachingLevelCsReq(betterproto.Message): + pass + + +@dataclass +class ChessRogueSkipTeachingLevelScRsp(betterproto.Message): + skip_reward_list: "ItemList" = betterproto.message_field(4) + retcode: int = betterproto.uint32_field(5) + + +@dataclass +class ChessRogueUpdateUnlockLevelScNotify(betterproto.Message): + area_id_list: List[int] = betterproto.uint32_field(9) + + +@dataclass +class ChessRogueEnterNextLayerCsReq(betterproto.Message): + pass + + +@dataclass +class ChessRogueEnterNextLayerScRsp(betterproto.Message): + dbdgahblgbb: "OJLEEFJELAP" = betterproto.message_field(5) + rogue_game_info: "ChessRogueGameInfo" = betterproto.message_field(7) + stage_info: "ChessRogueInfo" = betterproto.message_field(11) + retcode: int = betterproto.uint32_field(10) + + +@dataclass +class ChessRogueReRollDiceCsReq(betterproto.Message): + kchfjdajecm: int = betterproto.uint32_field(10) + + +@dataclass +class ChessRogueReRollDiceScRsp(betterproto.Message): + rogue_dice_info: "ChessRogueDiceInfo" = betterproto.message_field(10) + retcode: int = betterproto.uint32_field(9) + + +@dataclass +class ChessRogueConfirmRollCsReq(betterproto.Message): + kchfjdajecm: int = betterproto.uint32_field(8) + + +@dataclass +class ChessRogueConfirmRollScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(9) + rogue_dice_info: "ChessRogueDiceInfo" = betterproto.message_field(2) + + +@dataclass +class ChessRogueCheatRollCsReq(betterproto.Message): + kchfjdajecm: int = betterproto.uint32_field(8) + dice_surface_id: int = betterproto.uint32_field(13) + + +@dataclass +class ChessRogueCheatRollScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(15) + nljoldmcgai: int = betterproto.uint32_field(6) + dice_surface_id: int = betterproto.uint32_field(5) + rogue_dice_info: "ChessRogueDiceInfo" = betterproto.message_field(12) + + +@dataclass +class ChessRogueGiveUpRollCsReq(betterproto.Message): + pass + + +@dataclass +class ChessRogueGiveUpRollScRsp(betterproto.Message): + rogue_dice_info: "ChessRogueDiceInfo" = betterproto.message_field(6) + retcode: int = betterproto.uint32_field(9) + nkmjhejcolp: "ItemList" = betterproto.message_field(10) + + +@dataclass +class ChessRogueQuitCsReq(betterproto.Message): + pass + + +@dataclass +class ChessRogueQuitScRsp(betterproto.Message): + stage_info: "ChessRogueInfo" = betterproto.message_field(12) + retcode: int = betterproto.uint32_field(1) + query_info: "ChessRogueQueryInfo" = betterproto.message_field(9) + rogue_aeon_info: "ChessRogueAeonInfo" = betterproto.message_field(7) + rogue_get_info: "ChessRogueGetInfo" = betterproto.message_field(15) + level_info: "ChessRogueLevelInfo" = betterproto.message_field(3) + boikablfkec: "ChessRogueFinishInfo" = betterproto.message_field(8) + + +@dataclass +class ChessRogueCellUpdateNotify(betterproto.Message): + reason: "ChessRogueCellUpdateReason" = betterproto.enum_field(1) + cell_list: List["ChessRogueCell"] = betterproto.message_field(13) + eamgahffeco: int = betterproto.uint32_field(4) + dniibbhllnb: "RogueModifierSourceType" = betterproto.enum_field(3) + + +@dataclass +class ChessRogueQuestFinishNotify(betterproto.Message): + nnjccfeindo: int = betterproto.uint32_field(2) + quest_id: int = betterproto.uint32_field(3) + + +@dataclass +class GetChessRogueStoryInfoCsReq(betterproto.Message): + pass + + +@dataclass +class GetChessRogueStoryInfoScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(6) + idgiahopgaj: List["LAHJPFOOHEB"] = betterproto.message_field(5) + mnhmekkhkna: List["DIPMFOMGCGL"] = betterproto.message_field(1) + + +@dataclass +class SelectChessRogueSubStoryCsReq(betterproto.Message): + fahihdjfohm: int = betterproto.uint32_field(14) + ikmnamkjafa: int = betterproto.uint32_field(13) + rogue_dialogue_event_id: int = betterproto.uint32_field(5) + ifiijgngogp: int = betterproto.uint32_field(1) + + +@dataclass +class SelectChessRogueSubStoryScRsp(betterproto.Message): + ifiijgngogp: int = betterproto.uint32_field(7) + retcode: int = betterproto.uint32_field(9) + ikmnamkjafa: int = betterproto.uint32_field(13) + fahihdjfohm: int = betterproto.uint32_field(15) + rogue_dialogue_event_id: int = betterproto.uint32_field(12) + + +@dataclass +class FinishChessRogueSubStoryCsReq(betterproto.Message): + ikmnamkjafa: int = betterproto.uint32_field(1) + + +@dataclass +class FinishChessRogueSubStoryScRsp(betterproto.Message): + chess_rogue_main_story_id: int = betterproto.uint32_field(4) + ikmnamkjafa: int = betterproto.uint32_field(11) + retcode: int = betterproto.uint32_field(12) + + +@dataclass +class ChessRogueUpdateActionPointScNotify(betterproto.Message): + action_point: int = betterproto.int32_field(5) + + +@dataclass +class EnterChessRogueAeonRoomCsReq(betterproto.Message): + pass + + +@dataclass +class EnterChessRogueAeonRoomScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(5) + stage_info: "ChessRogueInfo" = betterproto.message_field(14) + + +@dataclass +class GetChessRogueStoryAeonTalkInfoCsReq(betterproto.Message): + talk_dialogue_id: int = betterproto.uint32_field(12) + + +@dataclass +class GetChessRogueStoryAeonTalkInfoScRsp(betterproto.Message): + kjcbneindhl: Dict[int, int] = betterproto.map_field( + 7, betterproto.TYPE_UINT32, betterproto.TYPE_UINT32 + ) + retcode: int = betterproto.uint32_field(5) + talk_dialogue_id: int = betterproto.uint32_field(13) + + +@dataclass +class SyncChessRogueMainStoryFinishScNotify(betterproto.Message): + kenpckfonok: int = betterproto.uint32_field(1) + chess_rogue_main_story_id: int = betterproto.uint32_field(12) + + +@dataclass +class SyncChessRogueNousValueScNotify(betterproto.Message): + nous_value_info: "ChessRogueNousValueInfo" = betterproto.message_field(11) + + +@dataclass +class GBEEJNBEBEP(betterproto.Message): + chess_rogue_main_story_id: int = betterproto.uint32_field(12) + status: "ChessRogueNousMainStoryStatus" = betterproto.enum_field(14) + + +@dataclass +class DIECDDGEBNB(betterproto.Message): + ikmnamkjafa: int = betterproto.uint32_field(4) + + +@dataclass +class GetChessRogueNousStoryInfoCsReq(betterproto.Message): + pass + + +@dataclass +class GetChessRogueNousStoryInfoScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(10) + idgiahopgaj: List["GBEEJNBEBEP"] = betterproto.message_field(1) + mnhmekkhkna: List["DIECDDGEBNB"] = betterproto.message_field(8) + + +@dataclass +class SyncChessRogueNousSubStoryScNotify(betterproto.Message): + ikmnamkjafa: int = betterproto.uint32_field(7) + + +@dataclass +class SyncChessRogueNousMainStoryScNotify(betterproto.Message): + idgiahopgaj: List["GBEEJNBEBEP"] = betterproto.message_field(3) + + +@dataclass +class IMNPEAJAJJO(betterproto.Message): + emllecgepck: List[int] = betterproto.uint32_field(8) + chess_rogue_main_story_id: int = betterproto.uint32_field(1) + ffheeidbhea: bool = betterproto.bool_field(6) + ikmnamkjafa: int = betterproto.uint32_field(5) + fjkgkaekbkj: bool = betterproto.bool_field(13) + oblhboeolaf: List[int] = betterproto.uint32_field(11) + ilmookbjhhc: List[int] = betterproto.uint32_field(14) + ffmdbdehheg: int = betterproto.uint32_field(9) + + +@dataclass +class ChessRogueDiceSurfaceInfo(betterproto.Message): + dice_slot_id: int = betterproto.uint32_field(15) + dice_surface_id: int = betterproto.uint32_field(14) + + +@dataclass +class ChessRogueDice(betterproto.Message): + branch_id: int = betterproto.uint32_field(7) + surface_id: int = betterproto.uint32_field(15) + slot_id: int = betterproto.uint32_field(2) + surface_list: List["ChessRogueDiceSurfaceInfo"] = betterproto.message_field(11) + + +@dataclass +class ChessRogueQueryDiceInfo(betterproto.Message): + dice_phase: "ChessRogueNousDicePhase" = betterproto.enum_field(14) + sus: Dict[int, bool] = betterproto.map_field( + 6, betterproto.TYPE_UINT32, betterproto.TYPE_BOOL + ) + dice_list: List["ChessRogueDice"] = betterproto.message_field(9) + surface_id_list: List[int] = betterproto.uint32_field(10) + + +@dataclass +class ChessRogueTalentInfo(betterproto.Message): + rogue_talent_info_list: "RogueTalentInfoList" = betterproto.message_field(5) + pofmjblmbji: int = betterproto.uint32_field(10) + + +@dataclass +class ChessRogueQueryDiffcultyInfo(betterproto.Message): + query_difficulty_id_list: List[int] = betterproto.uint32_field(6) + + +@dataclass +class ChessRogueNousEditDiceCsReq(betterproto.Message): + query_dice_info: "ChessRogueDice" = betterproto.message_field(4) + + +@dataclass +class ChessRogueNousEditDiceScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(2) + query_dice_info: "ChessRogueDice" = betterproto.message_field(10) + + +@dataclass +class ChessRogueNousDiceUpdateNotify(betterproto.Message): + mbibkhkkefb: "ChessRogueQueryDiceInfo" = betterproto.message_field(5) + + +@dataclass +class ChessRogueNousDiceSurfaceUnlockNotify(betterproto.Message): + caphiddhlfg: int = betterproto.uint32_field(11) + + +@dataclass +class ChessRogueNousGetRogueTalentInfoCsReq(betterproto.Message): + pass + + +@dataclass +class ChessRogueNousGetRogueTalentInfoScRsp(betterproto.Message): + pofmjblmbji: int = betterproto.uint32_field(8) + retcode: int = betterproto.uint32_field(2) + talent_info_list: "RogueTalentInfoList" = betterproto.message_field(14) + + +@dataclass +class ChessRogueNousEnableRogueTalentCsReq(betterproto.Message): + talent_id: int = betterproto.uint32_field(14) + + +@dataclass +class ChessRogueNousEnableRogueTalentScRsp(betterproto.Message): + pofmjblmbji: int = betterproto.uint32_field(12) + talent_info_list: "RogueTalentInfoList" = betterproto.message_field(2) + retcode: int = betterproto.uint32_field(14) + + +@dataclass +class AACOFIKDCPL(betterproto.Message): + ienpelbphdp: int = betterproto.uint32_field(2) + progress: int = betterproto.uint32_field(5) + + +@dataclass +class ODNNKBIMEFH(betterproto.Message): + keedplpaclp: List["AACOFIKDCPL"] = betterproto.message_field(6) + + +@dataclass +class EADGANMJIPK(betterproto.Message): + ibpfgebmilb: List[int] = betterproto.uint32_field(5) + + +@dataclass +class JCNJDFFCLDG(betterproto.Message): + hp: int = betterproto.int32_field(15) + jnboonpdoce: bool = betterproto.bool_field(9) + lkeblpijmgb: int = betterproto.int32_field(10) + oopkikmbbhh: List[int] = betterproto.uint32_field(7) + id: int = betterproto.uint32_field(2) + keedplpaclp: "ODNNKBIMEFH" = betterproto.message_field(3) + + +@dataclass +class MPJDIBCCOHF(betterproto.Message): + obcpgobaede: List[int] = betterproto.uint32_field(5) + miaiopgiphh: int = betterproto.uint32_field(1) + + +@dataclass +class DIFPDPLCIGD(betterproto.Message): + goneakbdgek: int = betterproto.uint32_field(7) + jfpnmoonlnj: int = betterproto.uint32_field(2) + + +@dataclass +class JMAANMPANHM(betterproto.Message): + clpmibdfpjc: int = betterproto.uint32_field(4) + noeimmhckpm: int = betterproto.uint32_field(3) + nhjalpdbogn: int = betterproto.uint32_field(15) + index: int = betterproto.uint32_field(7) + fpaibldakli: int = betterproto.uint32_field(12) + nkoffbmhapi: int = betterproto.uint32_field(14) + attack: int = betterproto.int32_field(9) + hp: int = betterproto.int32_field(5) + + +@dataclass +class EGDGHFLLMGN(betterproto.Message): + lcjhgdjdeng: int = betterproto.uint32_field(5) + total_turns: int = betterproto.uint32_field(7) + cfijipchhgo: int = betterproto.uint32_field(1) + cost_time: int = betterproto.uint32_field(8) + total_damage: int = betterproto.uint32_field(14) + total_auto_turns: int = betterproto.uint32_field(4) + + +@dataclass +class ChimeraGetDataCsReq(betterproto.Message): + pass + + +@dataclass +class ChimeraGetDataScRsp(betterproto.Message): + mfafnncjjng: List[int] = betterproto.uint32_field(8) + olldkajoajd: int = betterproto.uint32_field(301) + bbbgkchnock: int = betterproto.uint32_field(14) + eaiojcnlmng: int = betterproto.uint32_field(4) + bbmgiimecel: "OAPDMKKKEOL" = betterproto.enum_field(2) + retcode: int = betterproto.uint32_field(10) + cpbdbaidaeh: int = betterproto.uint32_field(220) + lfkfocjfncj: int = betterproto.uint32_field(3) + kilpnhjbpdb: int = betterproto.uint32_field(1095) + cjekjhpibjl: int = betterproto.uint32_field(7) + ncdaoblmhhp: List["DIFPDPLCIGD"] = betterproto.message_field(13) + ijeiommfpka: int = betterproto.uint32_field(1) + cagaplnhabb: int = betterproto.uint32_field(788) + cjkcnhclmgd: int = betterproto.uint32_field(12) + jfpnmoonlnj: int = betterproto.uint32_field(6) + gbemdnckkba: int = betterproto.uint32_field(11) + kiimkaeajal: List["JCNJDFFCLDG"] = betterproto.message_field(15) + lineup: "MPJDIBCCOHF" = betterproto.message_field(9) + + +@dataclass +class ChimeraSetLineupCsReq(betterproto.Message): + lineup: "MPJDIBCCOHF" = betterproto.message_field(14) + + +@dataclass +class ChimeraSetLineupScRsp(betterproto.Message): + lineup: "MPJDIBCCOHF" = betterproto.message_field(8) + retcode: int = betterproto.uint32_field(2) + + +@dataclass +class ChimeraFinishRoundCsReq(betterproto.Message): + stt: "EGDGHFLLMGN" = betterproto.message_field(14) + opamaeijcoh: List["JMAANMPANHM"] = betterproto.message_field(2) + molidikifgb: bool = betterproto.bool_field(3) + hjoeamdlbpl: int = betterproto.uint32_field(13) + lineup: "MPJDIBCCOHF" = betterproto.message_field(1) + mlbaljkcmcg: Dict[int, "ODNNKBIMEFH"] = betterproto.map_field( + 5, betterproto.TYPE_UINT32, betterproto.TYPE_MESSAGE + ) + hgodgdeaajo: List[int] = betterproto.uint32_field(15) + bahhnmlhalj: Dict[int, int] = betterproto.map_field( + 4, betterproto.TYPE_UINT32, betterproto.TYPE_UINT32 + ) + end_reason: "BIAKDFELJFM" = betterproto.enum_field(8) + + +@dataclass +class ChimeraFinishRoundScRsp(betterproto.Message): + molidikifgb: bool = betterproto.bool_field(2) + mfafnncjjng: List[int] = betterproto.uint32_field(12) + jfpnmoonlnj: int = betterproto.uint32_field(3) + end_reason: "BIAKDFELJFM" = betterproto.enum_field(5) + jieifdocohe: bool = betterproto.bool_field(13) + eaiojcnlmng: int = betterproto.uint32_field(7) + retcode: int = betterproto.uint32_field(1) + nahpkppmdkk: Dict[int, "ODNNKBIMEFH"] = betterproto.map_field( + 8, betterproto.TYPE_UINT32, betterproto.TYPE_MESSAGE + ) + goiakpgjlcb: List["JCNJDFFCLDG"] = betterproto.message_field(6) + ijeiommfpka: int = betterproto.uint32_field(15) + bbmgiimecel: "OAPDMKKKEOL" = betterproto.enum_field(9) + olldkajoajd: int = betterproto.uint32_field(10) + ncdaoblmhhp: List["DIFPDPLCIGD"] = betterproto.message_field(14) + ghkgcfclabf: Dict[int, "EADGANMJIPK"] = betterproto.map_field( + 4, betterproto.TYPE_UINT32, betterproto.TYPE_MESSAGE + ) + cjkcnhclmgd: int = betterproto.uint32_field(11) + + +@dataclass +class ChimeraStartEndlessCsReq(betterproto.Message): + pass + + +@dataclass +class ChimeraStartEndlessScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(12) + + +@dataclass +class ChimeraFinishEndlessRoundCsReq(betterproto.Message): + cpbdbaidaeh: int = betterproto.uint32_field(13) + lineup: "MPJDIBCCOHF" = betterproto.message_field(1) + stt: "EGDGHFLLMGN" = betterproto.message_field(15) + hgodgdeaajo: List[int] = betterproto.uint32_field(11) + pahmagpfddj: bool = betterproto.bool_field(14) + opamaeijcoh: List["JMAANMPANHM"] = betterproto.message_field(2) + + +@dataclass +class ChimeraFinishEndlessRoundScRsp(betterproto.Message): + lfkfocjfncj: int = betterproto.uint32_field(2) + igagibnelck: List["JCNJDFFCLDG"] = betterproto.message_field(15) + retcode: int = betterproto.uint32_field(5) + cpbdbaidaeh: int = betterproto.uint32_field(9) + bbbgkchnock: int = betterproto.uint32_field(8) + aebjngimhcj: int = betterproto.uint32_field(14) + pahmagpfddj: bool = betterproto.bool_field(11) + gbemdnckkba: int = betterproto.uint32_field(1) + + +@dataclass +class ChimeraQuitEndlessCsReq(betterproto.Message): + pass + + +@dataclass +class ChimeraQuitEndlessScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(7) + + +@dataclass +class ChimeraDoFinalRoundCsReq(betterproto.Message): + pahmagpfddj: bool = betterproto.bool_field(12) + hgodgdeaajo: List[int] = betterproto.uint32_field(7) + opamaeijcoh: List["JMAANMPANHM"] = betterproto.message_field(3) + stt: "EGDGHFLLMGN" = betterproto.message_field(14) + lineup: "MPJDIBCCOHF" = betterproto.message_field(1) + cpbdbaidaeh: int = betterproto.uint32_field(9) + + +@dataclass +class ChimeraDoFinalRoundScRsp(betterproto.Message): + cpbdbaidaeh: int = betterproto.uint32_field(12) + igagibnelck: List["JCNJDFFCLDG"] = betterproto.message_field(2) + pahmagpfddj: bool = betterproto.bool_field(5) + ncdaoblmhhp: List["DIFPDPLCIGD"] = betterproto.message_field(9) + jfpnmoonlnj: int = betterproto.uint32_field(4) + olldkajoajd: int = betterproto.uint32_field(15) + eaiojcnlmng: int = betterproto.uint32_field(8) + index: int = betterproto.uint32_field(3) + cagaplnhabb: int = betterproto.uint32_field(6) + retcode: int = betterproto.uint32_field(11) + + +@dataclass +class ChimeraRoundWorkStartCsReq(betterproto.Message): + flgjpheopaa: int = betterproto.uint32_field(1) + opamaeijcoh: List["JMAANMPANHM"] = betterproto.message_field(11) + mdfeekikbmj: int = betterproto.uint32_field(15) + lineup: "MPJDIBCCOHF" = betterproto.message_field(4) + + +@dataclass +class ChimeraRoundWorkStartScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(14) + + +@dataclass +class ClockParkGetInfoCsReq(betterproto.Message): + pass + + +@dataclass +class NLLJBBCJIAM(betterproto.Message): + odogfhenjep: List[int] = betterproto.uint32_field(11) + script_id: int = betterproto.uint32_field(4) + + +@dataclass +class ClockParkGetInfoScRsp(betterproto.Message): + ibjpcofdlji: List[int] = betterproto.uint32_field(8) + retcode: int = betterproto.uint32_field(3) + gfadcahlkfp: int = betterproto.uint32_field(14) + bnfhfhefmem: List["NLLJBBCJIAM"] = betterproto.message_field(4) + ediajgcbpfo: int = betterproto.uint32_field(12) + progress: int = betterproto.uint32_field(11) + + +@dataclass +class ClockParkUnlockTalentCsReq(betterproto.Message): + talent_id: int = betterproto.uint32_field(7) + + +@dataclass +class ClockParkUnlockTalentScRsp(betterproto.Message): + talent_id: int = betterproto.uint32_field(10) + retcode: int = betterproto.uint32_field(11) + + +@dataclass +class ClockParkStartScriptCsReq(betterproto.Message): + jmojeoalclo: List[int] = betterproto.uint32_field(2) + script_id: int = betterproto.uint32_field(4) + + +@dataclass +class ClockParkStartScriptScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(15) + script_id: int = betterproto.uint32_field(13) + + +@dataclass +class ClockParkGetOngoingScriptInfoCsReq(betterproto.Message): + pass + + +@dataclass +class LNIHJDAILDJ(betterproto.Message): + pass + + +@dataclass +class ACCBIGFANOA(betterproto.Message): + card_id: int = betterproto.uint32_field(5) + bjkhpadclhi: int = betterproto.uint32_field(9) + pneoolflnlk: List[int] = betterproto.uint32_field(2) + + +@dataclass +class HDCKCHPDMMI(betterproto.Message): + fodpdmpband: List["ACCBIGFANOA"] = betterproto.message_field(7) + pneoolflnlk: List[int] = betterproto.uint32_field(12) + + +@dataclass +class NNCCFPOOCKH(betterproto.Message): + ancpcpcljed: "HDCKCHPDMMI" = betterproto.message_field(12) + + +@dataclass +class MACHNDHAMNM(betterproto.Message): + ancpcpcljed: "HDCKCHPDMMI" = betterproto.message_field(7) + + +@dataclass +class IFBDBDCCOPO(betterproto.Message): + ancpcpcljed: "HDCKCHPDMMI" = betterproto.message_field(13) + + +@dataclass +class GLIJKLOOAPA(betterproto.Message): + ancpcpcljed: "HDCKCHPDMMI" = betterproto.message_field(14) + ecfagnkdaef: int = betterproto.uint32_field(8) + gacha_random: int = betterproto.uint32_field(10) + + +@dataclass +class ANBANKMLCLH(betterproto.Message): + ancpcpcljed: "HDCKCHPDMMI" = betterproto.message_field(15) + + +@dataclass +class EPPNKGOLAAP(betterproto.Message): + bgdoijphfdb: bool = betterproto.bool_field(14) + + +@dataclass +class LKBBKOJDDPD(betterproto.Message): + pnimpjfilgf: "LNIHJDAILDJ" = betterproto.message_field(5) + dhleejmiimo: "NNCCFPOOCKH" = betterproto.message_field(3) + oeofnnbljik: "MACHNDHAMNM" = betterproto.message_field(1) + gpbgdcmjhln: "IFBDBDCCOPO" = betterproto.message_field(15) + lnkpgggkmnk: "GLIJKLOOAPA" = betterproto.message_field(6) + aenefmcbfgm: "ANBANKMLCLH" = betterproto.message_field(13) + bciighioapl: "EPPNKGOLAAP" = betterproto.message_field(4) + gneooaifkib: bool = betterproto.bool_field(12) + a_h_i_d_j_b_j_g_g_p_p: int = betterproto.uint32_field(11) + + +@dataclass +class BMLOFPCNGKN(betterproto.Message): + ihlhdpnaekc: int = betterproto.int32_field(11) + ofcndemappl: int = betterproto.int32_field(9) + djfhcddifmi: int = betterproto.int32_field(8) + + +@dataclass +class IONCPPDEJEJ(betterproto.Message): + buff_id: int = betterproto.uint32_field(6) + unique_id: int = betterproto.uint64_field(11) + feonehhcjjm: int = betterproto.uint32_field(9) + + +@dataclass +class ECMILHCKOMO(betterproto.Message): + buff_list: List["IONCPPDEJEJ"] = betterproto.message_field(13) + + +@dataclass +class ClockParkGetOngoingScriptInfoScRsp(betterproto.Message): + obpfblnbfki: int = betterproto.uint32_field(6) + retcode: int = betterproto.uint32_field(3) + mjdogpbojip: "BMLOFPCNGKN" = betterproto.message_field(9) + rogue_buff_info: "ECMILHCKOMO" = betterproto.message_field(7) + eidlleolfgm: List[int] = betterproto.uint32_field(11) + ienphefangl: "LKBBKOJDDPD" = betterproto.message_field(1) + chobaogmlfn: int = betterproto.uint32_field(15) + cmgkeolcbip: str = betterproto.string_field(5) + kiekjeffphk: int = betterproto.uint32_field(14) + aigehhnhkpm: int = betterproto.uint32_field(8) + script_id: int = betterproto.uint32_field(10) + blhgbednfib: int = betterproto.uint32_field(12) + + +@dataclass +class OBNONMHMECK(betterproto.Message): + pass + + +@dataclass +class FFOMIBNCFKI(betterproto.Message): + ancpcpcljed: "HDCKCHPDMMI" = betterproto.message_field(11) + + +@dataclass +class AJEHAMDABNA(betterproto.Message): + omddfkmaape: int = betterproto.uint32_field(14) + is_win: bool = betterproto.bool_field(8) + + +@dataclass +class AMGHDCABJMJ(betterproto.Message): + avatar_id_list: List[int] = betterproto.uint32_field(2) + + +@dataclass +class INNNICFOLII(betterproto.Message): + jcnodamfffc: bool = betterproto.bool_field(2) + gacha_random: int = betterproto.uint32_field(8) + + +@dataclass +class CEOONFLONDJ(betterproto.Message): + is_win: bool = betterproto.bool_field(11) + omddfkmaape: int = betterproto.uint32_field(12) + + +@dataclass +class HELNOIHMDHA(betterproto.Message): + pass + + +@dataclass +class ClockParkHandleWaitOperationCsReq(betterproto.Message): + jfbckclpako: "OBNONMHMECK" = betterproto.message_field(9) + ipikflcefla: "FFOMIBNCFKI" = betterproto.message_field(8) + megnbbfilnl: "AJEHAMDABNA" = betterproto.message_field(7) + abkkdhapchn: "AMGHDCABJMJ" = betterproto.message_field(13) + lihjmeingik: "INNNICFOLII" = betterproto.message_field(6) + lmgglcncdhf: "CEOONFLONDJ" = betterproto.message_field(5) + fngfoaepfjn: "HELNOIHMDHA" = betterproto.message_field(11) + obpfblnbfki: int = betterproto.uint32_field(12) + script_id: int = betterproto.uint32_field(1) + a_h_i_d_j_b_j_g_g_p_p: int = betterproto.uint32_field(4) + + +@dataclass +class MDJLOJFMEMC(betterproto.Message): + eeehghkocji: bool = betterproto.bool_field(2) + progress: int = betterproto.uint32_field(11) + aigehhnhkpm: int = betterproto.uint32_field(9) + kiekjeffphk: int = betterproto.uint32_field(10) + reward: "ItemList" = betterproto.message_field(14) + script_id: int = betterproto.uint32_field(3) + kfdaicilnmb: bool = betterproto.bool_field(5) + + +@dataclass +class ClockParkHandleWaitOperationScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(11) + battle_info: "SceneBattleInfo" = betterproto.message_field(12) + ahidjbjggpp: int = betterproto.uint32_field(3) + ficfgdnhnge: int = betterproto.uint32_field(15) + koijfoffjnj: int = betterproto.uint32_field(4) + jfkdbmdomnk: "ClockParkPlayStatus" = betterproto.enum_field(6) + + +@dataclass +class ClockParkQuitScriptCsReq(betterproto.Message): + khnhpgdeimm: bool = betterproto.bool_field(11) + script_id: int = betterproto.uint32_field(3) + + +@dataclass +class ClockParkQuitScriptScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(11) + + +@dataclass +class ClockParkBattleEndScNotify(betterproto.Message): + ahidjbjggpp: int = betterproto.uint32_field(15) + retcode: int = betterproto.uint32_field(10) + + +@dataclass +class ClockParkUseBuffCsReq(betterproto.Message): + unique_id: int = betterproto.uint64_field(15) + ahidjbjggpp: int = betterproto.uint32_field(5) + script_id: int = betterproto.uint32_field(11) + + +@dataclass +class ClockParkUseBuffScRsp(betterproto.Message): + ancpcpcljed: "HDCKCHPDMMI" = betterproto.message_field(1841) + mjdogpbojip: "BMLOFPCNGKN" = betterproto.message_field(805) + script_id: int = betterproto.uint32_field(13) + a_h_i_d_j_b_j_g_g_p_p: int = betterproto.uint32_field(14) + retcode: int = betterproto.uint32_field(4) + rogue_buff_info: "ECMILHCKOMO" = betterproto.message_field(9) + + +@dataclass +class ClockParkFinishScriptScNotify(betterproto.Message): + rogue_finish_info: "MDJLOJFMEMC" = betterproto.message_field(1) + + +@dataclass +class Item(betterproto.Message): + unique_id: int = betterproto.uint32_field(7) + level: int = betterproto.uint32_field(6) + main_affix_id: int = betterproto.uint32_field(13) + num: int = betterproto.uint32_field(1) + promotion: int = betterproto.uint32_field(5) + rank: int = betterproto.uint32_field(8) + item_id: int = betterproto.uint32_field(2) + + +@dataclass +class ItemList(betterproto.Message): + item_list_: List["Item"] = betterproto.message_field(10) + + +@dataclass +class PileItem(betterproto.Message): + item_num: int = betterproto.uint32_field(11) + item_id: int = betterproto.uint32_field(6) + + +@dataclass +class ItemCost(betterproto.Message): + pile_item: "PileItem" = betterproto.message_field(6) + equipment_unique_id: int = betterproto.uint32_field(13) + relic_unique_id: int = betterproto.uint32_field(12) + + +@dataclass +class ItemCostData(betterproto.Message): + item_list: List["ItemCost"] = betterproto.message_field(10) + + +@dataclass +class IEKHJDECAPE(betterproto.Message): + item_id: int = betterproto.uint32_field(15) + item_count: int = betterproto.uint32_field(3) + + +@dataclass +class AKCPALGEMOL(betterproto.Message): + rank: int = betterproto.uint32_field(14) + tid: int = betterproto.uint32_field(2) + level: int = betterproto.uint32_field(11) + promotion: int = betterproto.uint32_field(1) + exp: int = betterproto.uint32_field(4) + + +@dataclass +class NHDBOFCFCJM(betterproto.Message): + sub_affix_list: List["RelicAffix"] = betterproto.message_field(15) + tid: int = betterproto.uint32_field(12) + main_affix_id: int = betterproto.uint32_field(8) + exp: int = betterproto.uint32_field(13) + level: int = betterproto.uint32_field(10) + + +@dataclass +class NDHOPEDOFOC(betterproto.Message): + oekhngffgkb: "IEKHJDECAPE" = betterproto.message_field(14) + adeoigebmdf: "AKCPALGEMOL" = betterproto.message_field(3) + fhgafcjcaoa: "NHDBOFCFCJM" = betterproto.message_field(13) + + +@dataclass +class AODIDFNPICF(betterproto.Message): + item_list: List["NDHOPEDOFOC"] = betterproto.message_field(1) + + +@dataclass +class Vector(betterproto.Message): + y: int = betterproto.sint32_field(15) + z: int = betterproto.sint32_field(8) + x: int = betterproto.sint32_field(11) + + +@dataclass +class MotionInfo(betterproto.Message): + pos: "Vector" = betterproto.message_field(13) + rot: "Vector" = betterproto.message_field(5) + + +@dataclass +class Vector4(betterproto.Message): + w: float = betterproto.float_field(4) + z: float = betterproto.float_field(2) + x: float = betterproto.float_field(15) + y: float = betterproto.float_field(6) + + +@dataclass +class SceneMonsterWaveParam(betterproto.Message): + dneampllfme: int = betterproto.uint32_field(7) + level: int = betterproto.uint32_field(15) + hard_level_group: int = betterproto.uint32_field(9) + elite_group: int = betterproto.uint32_field(14) + + +@dataclass +class SceneMonster(betterproto.Message): + cur_hp: int = betterproto.uint32_field(7) + max_hp: int = betterproto.uint32_field(10) + monster_id: int = betterproto.uint32_field(9) + + +@dataclass +class SceneMonsterWave(betterproto.Message): + battle_wave_id: int = betterproto.uint32_field(2) + monster_list: List["SceneMonster"] = betterproto.message_field(14) + monster_param: "SceneMonsterWaveParam" = betterproto.message_field(12) + jcdljghhaof: List["ItemList"] = betterproto.message_field(9) + battle_stage_id: int = betterproto.uint32_field(1) + + +@dataclass +class SceneBattleInfo(betterproto.Message): + jpgifchjdlk: "EvolveBuildBattleInfo" = betterproto.message_field(657) + battle_event: List["BattleEventBattleInfo"] = betterproto.message_field(1390) + battle_id: int = betterproto.uint32_field(2) + battle_avatar_list: List["BattleAvatar"] = betterproto.message_field(3) + battle_rogue_magic_info: "BattleRogueMagicInfo" = betterproto.message_field(988) + battle_target_info: Dict[int, "BattleTargetList"] = betterproto.map_field( + 1855, betterproto.TYPE_UINT32, betterproto.TYPE_MESSAGE + ) + mfkjokajjmj: "GIEIBEACBAO" = betterproto.message_field(435) + monster_wave_list: List["SceneMonsterWave"] = betterproto.message_field(9) + ddogjokeccl: int = betterproto.uint32_field(1) + stage_id: int = betterproto.uint32_field(4) + world_level: int = betterproto.uint32_field(6) + ajgpjglpmio: "LJGIAGLFHHC" = betterproto.message_field(1508) + logic_random_seed: int = betterproto.uint32_field(10) + nbckfdgmfdb: bool = betterproto.bool_field(11) + rounds_limit: int = betterproto.uint32_field(8) + buff_list: List["BattleBuff"] = betterproto.message_field(7) + + +@dataclass +class AetherDivideBattleInfo(betterproto.Message): + stage_id: int = betterproto.uint32_field(10) + monster_wave_list: List["SceneMonsterWave"] = betterproto.message_field(7) + buff_list: List["BattleBuff"] = betterproto.message_field(6) + logic_random_seed: int = betterproto.uint32_field(1) + battle_id: int = betterproto.uint32_field(5) + nbckfdgmfdb: bool = betterproto.bool_field(11) + battle_avatar_list: List["AetherAvatarInfo"] = betterproto.message_field(13) + + +@dataclass +class PHHKOMBGPPK(betterproto.Message): + assist_uid: int = betterproto.uint32_field(1) + avatar_type: "AvatarType" = betterproto.enum_field(13) + id: int = betterproto.uint32_field(11) + + +@dataclass +class MBKOCMMICPG(betterproto.Message): + return_item_list: "ItemList" = betterproto.message_field(4) + ebnkeiehnha: bool = betterproto.bool_field(13) + relic_ids: List[int] = betterproto.uint32_field(12) + + +@dataclass +class KHOCCHABNMN(betterproto.Message): + key: int = betterproto.uint32_field(15) + value: int = betterproto.uint32_field(14) + + +@dataclass +class ContentPackageGetDataCsReq(betterproto.Message): + pass + + +@dataclass +class ContentPackageGetDataScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(12) + data: "ContentPackageData" = betterproto.message_field(1) + + +@dataclass +class ContentPackageInfo(betterproto.Message): + content_id: int = betterproto.uint32_field(11) + status: "ContentPackageStatus" = betterproto.enum_field(9) + + +@dataclass +class ContentPackageData(betterproto.Message): + cur_content_id: int = betterproto.uint32_field(1) + content_package_list: List["ContentPackageInfo"] = betterproto.message_field(10) + + +@dataclass +class ContentPackageSyncDataScNotify(betterproto.Message): + data: "ContentPackageData" = betterproto.message_field(2) + + +@dataclass +class ContentPackageUnlockCsReq(betterproto.Message): + content_id: int = betterproto.uint32_field(5) + + +@dataclass +class ContentPackageUnlockScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(3) + content_id: int = betterproto.uint32_field(5) + + +@dataclass +class ContentPackageTransferScNotify(betterproto.Message): + pass + + +@dataclass +class DailyActivityInfo(betterproto.Message): + is_has_taken: bool = betterproto.bool_field(11) + daily_active_point: int = betterproto.uint32_field(6) + level: int = betterproto.uint32_field(13) + world_level: int = betterproto.uint32_field(8) + + +@dataclass +class TakeApRewardCsReq(betterproto.Message): + level: int = betterproto.uint32_field(1) + + +@dataclass +class TakeApRewardScRsp(betterproto.Message): + reward: "ItemList" = betterproto.message_field(3) + level: int = betterproto.uint32_field(5) + retcode: int = betterproto.uint32_field(11) + + +@dataclass +class GetDailyActiveInfoCsReq(betterproto.Message): + pass + + +@dataclass +class GetDailyActiveInfoScRsp(betterproto.Message): + daily_active_level_list: List["DailyActivityInfo"] = betterproto.message_field(1) + daily_active_quest_id_list: List[int] = betterproto.uint32_field(15) + daily_active_point: int = betterproto.uint32_field(8) + retcode: int = betterproto.uint32_field(5) + + +@dataclass +class DailyActiveInfoNotify(betterproto.Message): + daily_active_quest_id_list: List[int] = betterproto.uint32_field(5) + daily_active_level_list: List["DailyActivityInfo"] = betterproto.message_field(15) + daily_active_point: int = betterproto.uint32_field(3) + + +@dataclass +class TakeAllApRewardCsReq(betterproto.Message): + pass + + +@dataclass +class TakeAllApRewardScRsp(betterproto.Message): + take_reward_level_list: List[int] = betterproto.uint32_field(10) + reward: "ItemList" = betterproto.message_field(11) + retcode: int = betterproto.uint32_field(15) + + +@dataclass +class ServerLogSettings(betterproto.Message): + notify_tag_list: List["ServerLogTag"] = betterproto.enum_field(10) + notify_level: "ServerLogLevel" = betterproto.enum_field(14) + + +@dataclass +class GetServerLogSettingsCsReq(betterproto.Message): + pass + + +@dataclass +class GetServerLogSettingsScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(6) + settings: "ServerLogSettings" = betterproto.message_field(1) + + +@dataclass +class UpdateServerLogSettingsCsReq(betterproto.Message): + settings: "ServerLogSettings" = betterproto.message_field(14) + + +@dataclass +class UpdateServerLogSettingsScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(8) + + +@dataclass +class ServerLogScNotify(betterproto.Message): + level: "ServerLogLevel" = betterproto.enum_field(9) + hkligchhieg: str = betterproto.string_field(15) + tag: "ServerLogTag" = betterproto.enum_field(7) + lcpllgnjnaj: str = betterproto.string_field(3) + + +@dataclass +class LCMJFEHMCNF(betterproto.Message): + group_id: int = betterproto.uint32_field(9) + config_id: int = betterproto.uint32_field(10) + + +@dataclass +class OEDDOIJLGFG(betterproto.Message): + ffbfcclodkk: int = betterproto.uint32_field(3) + kacelkgcnei: int = betterproto.uint32_field(6) + faomfmmlmhd: "LCMJFEHMCNF" = betterproto.message_field(9) + + +@dataclass +class CFCAJKFEPAO(betterproto.Message): + msg: str = betterproto.string_field(9) + state: "OJIDJNDHDGA" = betterproto.enum_field(10) + benanabppjn: str = betterproto.string_field(6) + + +@dataclass +class KDOEJMHBBGI(betterproto.Message): + lopbajpaemi: List["CFCAJKFEPAO"] = betterproto.message_field(10) + dbgfaodbefc: "OEDDOIJLGFG" = betterproto.message_field(6) + + +@dataclass +class GetServerGraphDataCsReq(betterproto.Message): + eofciildilf: List["OEDDOIJLGFG"] = betterproto.message_field(4) + + +@dataclass +class GetServerGraphDataScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(9) + dcoihamjkhj: List["KDOEJMHBBGI"] = betterproto.message_field(2) + + +@dataclass +class DrinkMakerGuest(betterproto.Message): + unlocked_favor_tag_list: List[int] = betterproto.uint32_field(13) + guest_id: int = betterproto.uint32_field(2) + faith: int = betterproto.uint32_field(9) + + +@dataclass +class EEKFECDIHJE(betterproto.Message): + dbpgefglfjj: List[int] = betterproto.uint32_field(6) + jiblnlhcnkd: int = betterproto.uint32_field(4) + odmphfaniee: int = betterproto.uint32_field(11) + dgppffkihoc: int = betterproto.uint32_field(1) + kidbbfghecn: int = betterproto.uint32_field(12) + + +@dataclass +class MFLPAMAFJNC(betterproto.Message): + fgefcefkhmh: bool = betterproto.bool_field(1) + kcfpiecmgbd: int = betterproto.uint32_field(6) + + +@dataclass +class GetDrinkMakerDataCsReq(betterproto.Message): + pass + + +@dataclass +class GetDrinkMakerDataScRsp(betterproto.Message): + level: int = betterproto.uint32_field(1) + boinombhpcl: "EEKFECDIHJE" = betterproto.message_field(2) + dhakofagdof: int = betterproto.uint32_field(15) + retcode: int = betterproto.uint32_field(13) + hepalniojnp: int = betterproto.uint32_field(6) + amefgbicgdi: int = betterproto.uint32_field(12) + eaolmhoaaml: int = betterproto.uint32_field(8) + pjkibodpcki: List["DrinkMakerGuest"] = betterproto.message_field(3) + pcnnpejegef: List[int] = betterproto.uint32_field(4) + exp: int = betterproto.uint32_field(7) + + +@dataclass +class MakeDrinkCsReq(betterproto.Message): + lpmcgnjlbgd: "EEKFECDIHJE" = betterproto.message_field(5) + eaolmhoaaml: int = betterproto.uint32_field(4) + + +@dataclass +class MakeDrinkScRsp(betterproto.Message): + next_chat_id: int = betterproto.uint32_field(1) + retcode: int = betterproto.uint32_field(10) + is_succ: bool = betterproto.bool_field(5) + + +@dataclass +class EndDrinkMakerSequenceCsReq(betterproto.Message): + pass + + +@dataclass +class EndDrinkMakerSequenceScRsp(betterproto.Message): + next_sequence_id: int = betterproto.uint32_field(9) + level: int = betterproto.uint32_field(11) + exp: int = betterproto.uint32_field(2) + request_list: List["MFLPAMAFJNC"] = betterproto.message_field(8) + guest: "DrinkMakerGuest" = betterproto.message_field(4) + tips: int = betterproto.uint32_field(3) + retcode: int = betterproto.uint32_field(6) + reward: "ItemList" = betterproto.message_field(10) + + +@dataclass +class MakeMissionDrinkCsReq(betterproto.Message): + kcfpiecmgbd: int = betterproto.uint32_field(3) + lpmcgnjlbgd: "EEKFECDIHJE" = betterproto.message_field(15) + is_save: bool = betterproto.bool_field(9) + + +@dataclass +class MakeMissionDrinkScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(10) + is_save: bool = betterproto.bool_field(13) + is_succ: bool = betterproto.bool_field(14) + custom_drink: "EEKFECDIHJE" = betterproto.message_field(2) + + +@dataclass +class DrinkMakerDayEndScNotify(betterproto.Message): + ecilicnolfn: int = betterproto.uint32_field(2) + + +@dataclass +class DrinkMakerChallengeCsReq(betterproto.Message): + challenge_id: int = betterproto.uint32_field(7) + lpmcgnjlbgd: "EEKFECDIHJE" = betterproto.message_field(15) + + +@dataclass +class DrinkMakerChallengeScRsp(betterproto.Message): + challenge_id: int = betterproto.uint32_field(8) + fgefcefkhmh: bool = betterproto.bool_field(1) + reward: "ItemList" = betterproto.message_field(14) + retcode: int = betterproto.uint32_field(4) + + +@dataclass +class DrinkMakerUpdateTipsNotify(betterproto.Message): + amefgbicgdi: int = betterproto.uint32_field(2) + + +@dataclass +class GOAHFMLPDMF(betterproto.Message): + era_flipper_region_id: int = betterproto.uint32_field(9) + state: int = betterproto.uint32_field(2) + + +@dataclass +class KKEAENNDMKB(betterproto.Message): + ndpgblaaghk: List["GOAHFMLPDMF"] = betterproto.message_field(5) + + +@dataclass +class GetEraFlipperDataCsReq(betterproto.Message): + pass + + +@dataclass +class GetEraFlipperDataScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(1) + data: "KKEAENNDMKB" = betterproto.message_field(7) + + +@dataclass +class ChangeEraFlipperDataCsReq(betterproto.Message): + data: "KKEAENNDMKB" = betterproto.message_field(8) + + +@dataclass +class ChangeEraFlipperDataScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(9) + data: "KKEAENNDMKB" = betterproto.message_field(14) + + +@dataclass +class ResetEraFlipperDataCsReq(betterproto.Message): + pahmagpfddj: bool = betterproto.bool_field(3) + + +@dataclass +class ResetEraFlipperDataScRsp(betterproto.Message): + data: "KKEAENNDMKB" = betterproto.message_field(10) + retcode: int = betterproto.uint32_field(15) + pahmagpfddj: bool = betterproto.bool_field(9) + + +@dataclass +class EnterEraFlipperRegionCsReq(betterproto.Message): + state: int = betterproto.uint32_field(8) + era_flipper_region_id: int = betterproto.uint32_field(7) + + +@dataclass +class EnterEraFlipperRegionScRsp(betterproto.Message): + era_flipper_region_id: int = betterproto.uint32_field(14) + retcode: int = betterproto.uint32_field(4) + + +@dataclass +class EraFlipperDataChangeScNotify(betterproto.Message): + data: "KKEAENNDMKB" = betterproto.message_field(13) + floor_id: int = betterproto.uint32_field(1) + + +@dataclass +class EvolveBuildAvatar(betterproto.Message): + damage: float = betterproto.double_field(3) + avatar_id: int = betterproto.uint32_field(11) + avatar_type: "AvatarType" = betterproto.enum_field(6) + + +@dataclass +class EvolveBuildLevelInfo(betterproto.Message): + cur_game_exp: int = betterproto.uint32_field(13) + period_id_list: List[int] = betterproto.uint32_field(4) + avatar_list: List["EvolveBuildAvatar"] = betterproto.message_field(3) + season: "KLNIPNJCNMJ" = betterproto.enum_field(14) + battle_target_list: List["BattleTarget"] = betterproto.message_field(8) + battle_info: "EvolveBuildBattleInfo" = betterproto.message_field(15) + round_cnt: int = betterproto.uint32_field(7) + + +@dataclass +class CEENLALPDMK(betterproto.Message): + level_id: int = betterproto.uint32_field(6) + ceadmdamhmo: int = betterproto.uint32_field(2) + max_score: int = betterproto.uint32_field(12) + + +@dataclass +class IMGJIEBFGPF(betterproto.Message): + level: int = betterproto.uint32_field(10) + neciljojgan: int = betterproto.uint32_field(6) + + +@dataclass +class ECMMJLLHPMD(betterproto.Message): + najohihmabc: bool = betterproto.bool_field(8) + level_id: int = betterproto.uint32_field(13) + cadmfghaljg: bool = betterproto.bool_field(12) + lgdniigephh: List[int] = betterproto.uint32_field(6) + + +@dataclass +class PDFHJMMDGAE(betterproto.Message): + cokdnpeemag: List["IMGJIEBFGPF"] = betterproto.message_field(7) + item_value: int = betterproto.uint32_field(2) + mdcjfoafdjk: "KLNIPNJCNMJ" = betterproto.enum_field(15) + + +@dataclass +class PDICNBBKFNP(betterproto.Message): + eodgcnafiac: int = betterproto.uint32_field(14) + item_value: int = betterproto.uint32_field(2) + lcjnndgkidp: List["ECMMJLLHPMD"] = betterproto.message_field(6) + oofhjahfidh: bool = betterproto.bool_field(3) + dehghedinih: bool = betterproto.bool_field(1) + cokdnpeemag: List["IMGJIEBFGPF"] = betterproto.message_field(10) + klgheccbhcg: List["CEENLALPDMK"] = betterproto.message_field(12) + rogue_season_info: List["PDFHJMMDGAE"] = betterproto.message_field(5) + fjocdkifppc: List[int] = betterproto.uint32_field(15) + exp: int = betterproto.uint32_field(13) + lmeljcifbdf: List[int] = betterproto.uint32_field(9) + + +@dataclass +class EvolveBuildQueryInfoCsReq(betterproto.Message): + pass + + +@dataclass +class EvolveBuildQueryInfoScRsp(betterproto.Message): + rogue_current_info: "PDICNBBKFNP" = betterproto.message_field(10) + level_info: "EvolveBuildLevelInfo" = betterproto.message_field(9) + dhmbdiibklm: List["EvolveBuildLevelInfo"] = betterproto.message_field(8) + retcode: int = betterproto.uint32_field(4) + + +@dataclass +class EvolveBuildStartLevelCsReq(betterproto.Message): + jiapjhdlfbj: "KPKKKJPJCPC" = betterproto.message_field(5) + avatar_list: List["EvolveBuildAvatar"] = betterproto.message_field(3) + level_id: int = betterproto.uint32_field(15) + + +@dataclass +class EvolveBuildStartLevelScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(12) + level_info: "EvolveBuildLevelInfo" = betterproto.message_field(11) + nopheehjhek: "SceneBattleInfo" = betterproto.message_field(8) + + +@dataclass +class EvolveBuildStartStageCsReq(betterproto.Message): + level_id: int = betterproto.uint32_field(6) + + +@dataclass +class EvolveBuildStartStageScRsp(betterproto.Message): + level_info: "EvolveBuildLevelInfo" = betterproto.message_field(5) + nopheehjhek: "SceneBattleInfo" = betterproto.message_field(1) + retcode: int = betterproto.uint32_field(9) + + +@dataclass +class EvolveBuildGiveupCsReq(betterproto.Message): + level_id: int = betterproto.uint32_field(9) + + +@dataclass +class EvolveBuildGiveupScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(4) + level_info: "EvolveBuildLevelInfo" = betterproto.message_field(3) + + +@dataclass +class EvolveBuildLeaveCsReq(betterproto.Message): + pass + + +@dataclass +class EvolveBuildLeaveScRsp(betterproto.Message): + level_info: "EvolveBuildLevelInfo" = betterproto.message_field(14) + retcode: int = betterproto.uint32_field(6) + + +@dataclass +class EvolveBuildFinishScNotify(betterproto.Message): + coin: int = betterproto.uint32_field(6) + cur_period_type: int = betterproto.uint32_field(15) + exp: int = betterproto.uint32_field(5) + battle_result_type: "DLHCMCNIHII" = betterproto.enum_field(3) + is_lose: bool = betterproto.bool_field(7) + level_id: int = betterproto.uint32_field(9) + wave: int = betterproto.uint32_field(4) + score: int = betterproto.uint32_field(2) + level_info: "EvolveBuildLevelInfo" = betterproto.message_field(14) + + +@dataclass +class EvolveBuildReRandomStageCsReq(betterproto.Message): + level_id: int = betterproto.uint32_field(12) + + +@dataclass +class EvolveBuildReRandomStageScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(14) + jgpbflccijp: "ECMMJLLHPMD" = betterproto.message_field(9) + + +@dataclass +class EvolveBuildShopAbilityUpCsReq(betterproto.Message): + neciljojgan: int = betterproto.uint32_field(11) + level: int = betterproto.uint32_field(7) + + +@dataclass +class EvolveBuildShopAbilityUpScRsp(betterproto.Message): + neciljojgan: int = betterproto.uint32_field(4) + level: int = betterproto.uint32_field(12) + retcode: int = betterproto.uint32_field(14) + + +@dataclass +class EvolveBuildShopAbilityDownCsReq(betterproto.Message): + level: int = betterproto.uint32_field(4) + neciljojgan: int = betterproto.uint32_field(10) + + +@dataclass +class EvolveBuildShopAbilityDownScRsp(betterproto.Message): + neciljojgan: int = betterproto.uint32_field(12) + retcode: int = betterproto.uint32_field(2) + level: int = betterproto.uint32_field(3) + + +@dataclass +class EvolveBuildTakeExpRewardCsReq(betterproto.Message): + pass + + +@dataclass +class EvolveBuildTakeExpRewardScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(1) + reward: "ItemList" = betterproto.message_field(12) + eodgcnafiac: int = betterproto.uint32_field(3) + + +@dataclass +class EvolveBuildShopAbilityResetCsReq(betterproto.Message): + mdcjfoafdjk: "KLNIPNJCNMJ" = betterproto.enum_field(10) + + +@dataclass +class EvolveBuildShopAbilityResetScRsp(betterproto.Message): + cokdnpeemag: List["IMGJIEBFGPF"] = betterproto.message_field(7) + retcode: int = betterproto.uint32_field(13) + item_value: int = betterproto.uint32_field(8) + mdcjfoafdjk: "KLNIPNJCNMJ" = betterproto.enum_field(10) + + +@dataclass +class EvolveBuildCoinNotify(betterproto.Message): + item_value: int = betterproto.uint32_field(15) + mdcjfoafdjk: "KLNIPNJCNMJ" = betterproto.enum_field(8) + + +@dataclass +class LCAOFIDPICA(betterproto.Message): + level_id: int = betterproto.uint32_field(3) + + +@dataclass +class OBBGCAMDHFG(betterproto.Message): + retcode: int = betterproto.uint32_field(12) + level_id: int = betterproto.uint32_field(9) + + +@dataclass +class ExpeditionInfo(betterproto.Message): + start_expedition_time: int = betterproto.int64_field(9) + id: int = betterproto.uint32_field(10) + avatar_id_list: List[int] = betterproto.uint32_field(5) + total_duration: int = betterproto.uint32_field(8) + + +@dataclass +class ActivityExpedition(betterproto.Message): + ojfnlmhmlof: int = betterproto.uint32_field(4) + ipgeclelhgj: int = betterproto.uint32_field(14) + id: int = betterproto.uint32_field(2) + start_expedition_time: int = betterproto.int64_field(1) + fnggnbmofaa: int = betterproto.uint32_field(8) + avatar_id_list: List[int] = betterproto.uint32_field(5) + + +@dataclass +class GetExpeditionDataCsReq(betterproto.Message): + pass + + +@dataclass +class GetExpeditionDataScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(11) + fnalloldglm: List[int] = betterproto.uint32_field(9) + fjgimkepjob: List[int] = betterproto.uint32_field(5) + expedition_info: List["ExpeditionInfo"] = betterproto.message_field(6) + activity_expedition_info: List["ActivityExpedition"] = betterproto.message_field(8) + total_expedition_count: int = betterproto.uint32_field(15) + jfjpadlalmd: List[int] = betterproto.uint32_field(12) + + +@dataclass +class AcceptExpeditionCsReq(betterproto.Message): + accept_expedition: "ExpeditionInfo" = betterproto.message_field(10) + + +@dataclass +class AcceptExpeditionScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(10) + accept_expedition: "ExpeditionInfo" = betterproto.message_field(6) + + +@dataclass +class AcceptMultipleExpeditionCsReq(betterproto.Message): + expedition: List["ExpeditionInfo"] = betterproto.message_field(4) + + +@dataclass +class AcceptMultipleExpeditionScRsp(betterproto.Message): + accept_multi_expedition: List["ExpeditionInfo"] = betterproto.message_field(1) + retcode: int = betterproto.uint32_field(7) + + +@dataclass +class CancelExpeditionCsReq(betterproto.Message): + expedition_id: int = betterproto.uint32_field(9) + + +@dataclass +class CancelExpeditionScRsp(betterproto.Message): + expedition_id: int = betterproto.uint32_field(9) + retcode: int = betterproto.uint32_field(6) + + +@dataclass +class TakeExpeditionRewardCsReq(betterproto.Message): + expedition_id: int = betterproto.uint32_field(4) + + +@dataclass +class TakeExpeditionRewardScRsp(betterproto.Message): + expedition_id: int = betterproto.uint32_field(4) + retcode: int = betterproto.uint32_field(15) + reward: "ItemList" = betterproto.message_field(13) + extra_reward: "ItemList" = betterproto.message_field(14) + + +@dataclass +class TakeMultipleExpeditionRewardCsReq(betterproto.Message): + take_multi_expedition: List[int] = betterproto.uint32_field(12) + + +@dataclass +class TakeMultipleExpeditionRewardScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(1) + reward_list: List["ItemList"] = betterproto.message_field(15) + extra_reward: "ItemList" = betterproto.message_field(11) + extra_reward_list: List["ItemList"] = betterproto.message_field(2) + reward: "ItemList" = betterproto.message_field(5) + reward_expedition: List[int] = betterproto.uint32_field(10) + + +@dataclass +class ExpeditionDataChangeScNotify(betterproto.Message): + total_expedition_count: int = betterproto.uint32_field(3) + fnalloldglm: List[int] = betterproto.uint32_field(7) + jfjpadlalmd: List[int] = betterproto.uint32_field(4) + activity_expedition_info: List["ActivityExpedition"] = betterproto.message_field(1) + expedition_info: List["ExpeditionInfo"] = betterproto.message_field(6) + + +@dataclass +class AcceptActivityExpeditionCsReq(betterproto.Message): + lgkjlfjgoje: "ActivityExpedition" = betterproto.message_field(12) + + +@dataclass +class AcceptActivityExpeditionScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(14) + lgkjlfjgoje: "ActivityExpedition" = betterproto.message_field(5) + + +@dataclass +class CancelActivityExpeditionCsReq(betterproto.Message): + mpgemlglhbh: int = betterproto.uint32_field(15) + + +@dataclass +class CancelActivityExpeditionScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(15) + mpgemlglhbh: int = betterproto.uint32_field(13) + + +@dataclass +class TakeActivityExpeditionRewardCsReq(betterproto.Message): + mpgemlglhbh: int = betterproto.uint32_field(12) + + +@dataclass +class TakeActivityExpeditionRewardScRsp(betterproto.Message): + mpgemlglhbh: int = betterproto.uint32_field(5) + extra_reward: "ItemList" = betterproto.message_field(1) + retcode: int = betterproto.uint32_field(9) + reward: "ItemList" = betterproto.message_field(10) + score_id: int = betterproto.uint32_field(7) + + +@dataclass +class TakeMultipleActivityExpeditionRewardCsReq(betterproto.Message): + gomdmnhmmnh: List[int] = betterproto.uint32_field(8) + + +@dataclass +class MMNJMINGAHJ(betterproto.Message): + mpgemlglhbh: int = betterproto.uint32_field(11) + score_id: int = betterproto.uint32_field(10) + reward: "ItemList" = betterproto.message_field(8) + extra_reward: "ItemList" = betterproto.message_field(9) + + +@dataclass +class TakeMultipleActivityExpeditionRewardScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(12) + jieeelikijm: List[int] = betterproto.uint32_field(6) + cdndfceedco: List["MMNJMINGAHJ"] = betterproto.message_field(15) + + +@dataclass +class GCAIEMMCPDH(betterproto.Message): + buff_list: List[int] = betterproto.uint32_field(6) + avatar_list: List["KJMFEOCKCML"] = betterproto.message_field(10) + + +@dataclass +class FHBLGMPMIIE(betterproto.Message): + jgajkoefgpc: Dict[int, int] = betterproto.map_field( + 1, betterproto.TYPE_UINT32, betterproto.TYPE_UINT32 + ) + hkmmnfghfpb: List[int] = betterproto.uint32_field(2) + gblooeppgdm: Dict[int, "GCAIEMMCPDH"] = betterproto.map_field( + 15, betterproto.TYPE_UINT32, betterproto.TYPE_MESSAGE + ) + bejcaldilnc: int = betterproto.uint32_field(3) + edhnakfofgj: List[int] = betterproto.uint32_field(10) + amdhncjjoph: List[int] = betterproto.uint32_field(12) + njngbpjemcl: List[int] = betterproto.uint32_field(9) + + +@dataclass +class GetFantasticStoryActivityDataCsReq(betterproto.Message): + bejcaldilnc: int = betterproto.uint32_field(13) + + +@dataclass +class GetFantasticStoryActivityDataScRsp(betterproto.Message): + fpepicfcffm: "FHBLGMPMIIE" = betterproto.message_field(11) + retcode: int = betterproto.uint32_field(9) + + +@dataclass +class FinishChapterScNotify(betterproto.Message): + fpepicfcffm: "FHBLGMPMIIE" = betterproto.message_field(1) + + +@dataclass +class KJMFEOCKCML(betterproto.Message): + avatar_id: int = betterproto.uint32_field(12) + avatar_type: "AvatarType" = betterproto.enum_field(10) + + +@dataclass +class EnterFantasticStoryActivityStageCsReq(betterproto.Message): + bejcaldilnc: int = betterproto.uint32_field(11) + avatar_list: List["KJMFEOCKCML"] = betterproto.message_field(8) + buff_list: List[int] = betterproto.uint32_field(4) + battle_id: int = betterproto.uint32_field(6) + + +@dataclass +class EnterFantasticStoryActivityStageScRsp(betterproto.Message): + bejcaldilnc: int = betterproto.uint32_field(14) + retcode: int = betterproto.uint32_field(2) + battle_info: "SceneBattleInfo" = betterproto.message_field(11) + battle_id: int = betterproto.uint32_field(3) + + +@dataclass +class FantasticStoryActivityBattleEndScNotify(betterproto.Message): + pkklpbbnnce: int = betterproto.uint32_field(5) + bejcaldilnc: int = betterproto.uint32_field(9) + battle_id: int = betterproto.uint32_field(15) + + +@dataclass +class FeverTimeActivityData(betterproto.Message): + nlpklpccjpl: int = betterproto.uint32_field(5) + jbolaafdkan: int = betterproto.uint32_field(12) + plikadkklgd: "FeverTimeBattleRank" = betterproto.enum_field(8) + + +@dataclass +class GetFeverTimeActivityDataCsReq(betterproto.Message): + pass + + +@dataclass +class GetFeverTimeActivityDataScRsp(betterproto.Message): + caaejfijidj: List["FeverTimeActivityData"] = betterproto.message_field(4) + retcode: int = betterproto.uint32_field(10) + + +@dataclass +class FeverTimeActivityBattleEndScNotify(betterproto.Message): + fhfmfmlllgd: int = betterproto.uint32_field(12) + id: int = betterproto.uint32_field(2) + lfjkkfgpkdm: "FeverTimeBattleRank" = betterproto.enum_field(6) + hoehiobiiej: int = betterproto.uint32_field(7) + + +@dataclass +class EnterFeverTimeActivityStageCsReq(betterproto.Message): + ffinmbacahh: int = betterproto.uint32_field(2) + id: int = betterproto.uint32_field(5) + avatar_list: List["FeverTimeAvatar"] = betterproto.message_field(6) + gcjeicifjgi: int = betterproto.uint32_field(14) + + +@dataclass +class EnterFeverTimeActivityStageScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(8) + battle_info: "SceneBattleInfo" = betterproto.message_field(7) + id: int = betterproto.uint32_field(15) + + +@dataclass +class FightEnterCsReq(betterproto.Message): + fgojlpaejec: int = betterproto.uint32_field(15) + uid: int = betterproto.uint32_field(8) + aokcmmpfgbc: str = betterproto.string_field(3) + mkiniofgiag: int = betterproto.uint32_field(14) + icmfpnpijjf: int = betterproto.uint32_field(6) + client_res_version: int = betterproto.uint32_field(9) + kpkdnmdajgl: int = betterproto.uint64_field(5) + platform: int = betterproto.uint32_field(2) + + +@dataclass +class FightEnterScRsp(betterproto.Message): + secret_key_seed: int = betterproto.uint64_field(11) + jlpkeobincp: bool = betterproto.bool_field(5) + retcode: int = betterproto.uint32_field(4) + mkiniofgiag: int = betterproto.uint32_field(13) + server_timestamp_ms: int = betterproto.uint64_field(15) + + +@dataclass +class FightLeaveScNotify(betterproto.Message): + cagjmmmfdli: int = betterproto.uint32_field(2) + + +@dataclass +class FightKickOutScNotify(betterproto.Message): + kick_type: "FightKickoutType" = betterproto.enum_field(15) + + +@dataclass +class FightHeartBeatCsReq(betterproto.Message): + client_time_ms: int = betterproto.uint64_field(3) + + +@dataclass +class FightHeartBeatScRsp(betterproto.Message): + client_time_ms: int = betterproto.uint64_field(9) + retcode: int = betterproto.uint32_field(11) + server_time_ms: int = betterproto.uint64_field(8) + + +@dataclass +class FightSessionStopScNotify(betterproto.Message): + pfffjngnpom: "PPGGKMDAOEA" = betterproto.message_field(11) + + +@dataclass +class FightGeneralCsReq(betterproto.Message): + jjcmfkjhcfa: int = betterproto.uint32_field(9) + mbbdnlncejd: bytes = betterproto.bytes_field(4) + + +@dataclass +class FightGeneralScRsp(betterproto.Message): + mbbdnlncejd: bytes = betterproto.bytes_field(2) + retcode: int = betterproto.uint32_field(4) + jjcmfkjhcfa: int = betterproto.uint32_field(5) + + +@dataclass +class FightGeneralScNotify(betterproto.Message): + jjcmfkjhcfa: int = betterproto.uint32_field(15) + mbbdnlncejd: bytes = betterproto.bytes_field(11) + + +@dataclass +class JHPKNHHNAPP(betterproto.Message): + elinmpkbefl: int = betterproto.uint32_field(13) + ahmdobiceca: List["FightGeneralScNotify"] = betterproto.message_field(14) + lbgdlhkeekc: bytes = betterproto.bytes_field(8) + jblecmapfdc: List[int] = betterproto.uint32_field(3) + kbjfonagbhk: bytes = betterproto.bytes_field(4) + + +@dataclass +class AIDOADPOOFG(betterproto.Message): + lipjdjpmokb: List["CBBDIOMIFHD"] = betterproto.message_field(13) + + +@dataclass +class FightActivityGroup(betterproto.Message): + taken_difficulty_level_reward_list: List[int] = betterproto.uint32_field(10) + group_id: int = betterproto.uint32_field(9) + passed_max_difficulty_level: int = betterproto.uint32_field(14) + endless_max_wave: int = betterproto.uint32_field(15) + + +@dataclass +class GetFightActivityDataCsReq(betterproto.Message): + pass + + +@dataclass +class GetFightActivityDataScRsp(betterproto.Message): + jkhifdghjdo: List["FightActivityGroup"] = betterproto.message_field(2) + world_level: int = betterproto.uint32_field(9) + kaiompfbgkl: bool = betterproto.bool_field(14) + retcode: int = betterproto.uint32_field(11) + dgnfcmdjopa: Dict[int, int] = betterproto.map_field( + 12, betterproto.TYPE_UINT32, betterproto.TYPE_UINT32 + ) + + +@dataclass +class FightActivityDataChangeScNotify(betterproto.Message): + dgnfcmdjopa: Dict[int, int] = betterproto.map_field( + 9, betterproto.TYPE_UINT32, betterproto.TYPE_UINT32 + ) + jkhifdghjdo: List["FightActivityGroup"] = betterproto.message_field(7) + + +@dataclass +class NPEDHHCKLIA(betterproto.Message): + avatar_type: "AvatarType" = betterproto.enum_field(12) + avatar_id: int = betterproto.uint32_field(14) + + +@dataclass +class EnterFightActivityStageCsReq(betterproto.Message): + nedfibonlkb: int = betterproto.uint32_field(1) + avatar_list: List[int] = betterproto.uint32_field(13) + group_id: int = betterproto.uint32_field(3) + item_list: List[int] = betterproto.uint32_field(5) + fopnlgbgagh: List["NPEDHHCKLIA"] = betterproto.message_field(8) + + +@dataclass +class EnterFightActivityStageScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(5) + group_id: int = betterproto.uint32_field(12) + battle_info: "SceneBattleInfo" = betterproto.message_field(3) + nedfibonlkb: int = betterproto.uint32_field(11) + + +@dataclass +class TakeFightActivityRewardCsReq(betterproto.Message): + nedfibonlkb: int = betterproto.uint32_field(2) + group_id: int = betterproto.uint32_field(1) + + +@dataclass +class TakeFightActivityRewardScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(6) + nedfibonlkb: int = betterproto.uint32_field(9) + reward: "ItemList" = betterproto.message_field(2) + group_id: int = betterproto.uint32_field(14) + + +@dataclass +class IKLNILKPENA(betterproto.Message): + jbolaafdkan: int = betterproto.uint32_field(10) + challenge_id: int = betterproto.uint32_field(13) + aeieojgcmmo: int = betterproto.uint32_field(14) + plikadkklgd: "HGDAPJPKFFB" = betterproto.enum_field(3) + + +@dataclass +class GetFightFestDataCsReq(betterproto.Message): + pass + + +@dataclass +class GetFightFestDataScRsp(betterproto.Message): + item_value: int = betterproto.uint32_field(10) + retcode: int = betterproto.uint32_field(14) + challenge_list: List["IKLNILKPENA"] = betterproto.message_field(15) + score_id: int = betterproto.uint32_field(7) + mfgonhjgipp: List[int] = betterproto.uint32_field(12) + + +@dataclass +class AFODMEJODLG(betterproto.Message): + avatar_type: "AvatarType" = betterproto.enum_field(4) + id: int = betterproto.uint32_field(5) + + +@dataclass +class StartFightFestCsReq(betterproto.Message): + id: int = betterproto.uint32_field(10) + mfgonhjgipp: List[int] = betterproto.uint32_field(15) + event_id: int = betterproto.uint32_field(8) + type: "APLOAGDIBKI" = betterproto.enum_field(13) + avatar_list: List["AFODMEJODLG"] = betterproto.message_field(5) + + +@dataclass +class StartFightFestScRsp(betterproto.Message): + event_id: int = betterproto.uint32_field(7) + retcode: int = betterproto.uint32_field(9) + battle_info: "SceneBattleInfo" = betterproto.message_field(11) + id: int = betterproto.uint32_field(10) + type: "APLOAGDIBKI" = betterproto.enum_field(1) + + +@dataclass +class FightFestScoreUpdateNotify(betterproto.Message): + gnpkpljlabm: int = betterproto.uint32_field(3) + score_id: int = betterproto.uint32_field(2) + + +@dataclass +class FightFestUnlockSkillNotify(betterproto.Message): + ejjehjmmbgj: int = betterproto.uint32_field(10) + + +@dataclass +class FightFestUpdateChallengeRecordNotify(betterproto.Message): + hoehiobiiej: int = betterproto.uint32_field(7) + fkpepbmjhkn: "HGDAPJPKFFB" = betterproto.enum_field(9) + rank: "HGDAPJPKFFB" = betterproto.enum_field(11) + jbolaafdkan: int = betterproto.uint32_field(1) + challenge_id: int = betterproto.uint32_field(2) + + +@dataclass +class FightFestUpdateCoinNotify(betterproto.Message): + item_value: int = betterproto.uint32_field(4) + + +@dataclass +class KPBFCKNEEIA(betterproto.Message): + oilpchbijno: "FFJPPNGGLFF" = betterproto.enum_field(15) + blgnmalbolo: int = betterproto.int32_field(9) + ldnbeidjbhi: int = betterproto.uint64_field(5) + + +@dataclass +class GLDHEPJPMFM(betterproto.Message): + action_result_list: List["KPBFCKNEEIA"] = betterproto.message_field(10) + + +@dataclass +class PFGAIEBGHCP(betterproto.Message): + x: float = betterproto.float_field(10) + y: float = betterproto.float_field(6) + + +@dataclass +class JEJDMMBDALP(betterproto.Message): + kbcejinfnnj: "PFGAIEBGHCP" = betterproto.message_field(4) + item_id: int = betterproto.uint32_field(10) + + +@dataclass +class AKOKICDPFMP(betterproto.Message): + lgpiemdlhjm: "LBAOGIBPJOP" = betterproto.message_field(1365) + phmcjejidja: "GLDNBPFCNHD" = betterproto.message_field(1070) + rogue_finish_info: "ICAOOPPMJDJ" = betterproto.message_field( + 1206 + ) + mejdmjikimo: "MAOGFDKDCKM" = betterproto.message_field(742) + jhfgdijpfcg: "GOCKGIGBDCG" = betterproto.message_field(1622) + a_h_e_h_k_c_i_l_d_f_a: int = betterproto.uint32_field(15) + + +@dataclass +class GEMEBEBMIAH(betterproto.Message): + lndigheihln: List["AKOKICDPFMP"] = betterproto.message_field(9) + + +@dataclass +class LBAOGIBPJOP(betterproto.Message): + ceifkjieaje: "JOMKPEGEFMP" = betterproto.enum_field(7) + likhclpmhjk: bool = betterproto.bool_field(9) + hjefolkgaei: "JOMKPEGEFMP" = betterproto.enum_field(6) + pcmgagahblk: List[int] = betterproto.uint32_field(14) + moddklndamk: int = betterproto.uint32_field(8) + lipjdjpmokb: List["CBBDIOMIFHD"] = betterproto.message_field(582) + khcmofpfoak: int = betterproto.uint32_field(15) + jjefbpkpkbk: List[int] = betterproto.uint32_field(12) + nlibkabfgcc: int = betterproto.uint32_field(10) + bbdoplekiac: int = betterproto.uint32_field(11) + level_id: int = betterproto.uint32_field(13) + jikeigbcabb: bool = betterproto.bool_field(5) + pbfaiojjgnl: int = betterproto.uint32_field(1) + jijhaaihncn: int = betterproto.uint32_field(4) + eigabckednp: int = betterproto.uint32_field(3) + dkpnenbhelh: int = betterproto.uint32_field(2) + + +@dataclass +class GKLOALDHNEF(betterproto.Message): + item_id: int = betterproto.uint32_field(6) + jojahiafnlk: int = betterproto.uint32_field(2) + total_damage: int = betterproto.int32_field(9) + jphednecagd: int = betterproto.int32_field(11) + falbkimmpih: int = betterproto.int32_field(1) + + +@dataclass +class ICAOOPPMJDJ(betterproto.Message): + is_win: bool = betterproto.bool_field(6) + kjpmohfiilo: "EEIBHJPNJCF" = betterproto.enum_field(14) + djeeeabmddk: bool = betterproto.bool_field(13) + blkfgajhmlk: int = betterproto.uint32_field(2) + clbnhpeabfk: int = betterproto.int32_field(15) + chllmfjgppa: int = betterproto.uint32_field(10) + bpipobhcmfd: List["GKLOALDHNEF"] = betterproto.message_field(3) + + +@dataclass +class DCDNIAJCEHN(betterproto.Message): + hdblelebkho: int = betterproto.int32_field(577) + buff_id: int = betterproto.uint32_field(439) + time: float = betterproto.float_field(6) + kamihnejmfg: "LKKAJCACIJI" = betterproto.enum_field(12) + cipiclllijh: int = betterproto.uint32_field(14) + jlcikblnenh: int = betterproto.uint32_field(777) + jijhaaihncn: int = betterproto.uint32_field(1401) + dkpnenbhelh: int = betterproto.uint32_field(506) + text_id: int = betterproto.uint32_field(1884) + djoadecjpob: "PAJNHIAGODD" = betterproto.enum_field(3) + mnbemgnnfod: float = betterproto.float_field(673) + attack: int = betterproto.int32_field(11) + fnihjjjgoee: "PFGAIEBGHCP" = betterproto.message_field(15) + idabofpkokn: int = betterproto.uint32_field(1253) + jljigeplpmh: int = betterproto.uint32_field(1) + iaaggmkgodc: "PFGAIEBGHCP" = betterproto.message_field(2) + level: int = betterproto.uint32_field(862) + plfkoccdbag: bool = betterproto.bool_field(2005) + cclmfabdena: "FIPPKLCOEGJ" = betterproto.enum_field(1417) + godnaalnokl: "PFGAIEBGHCP" = betterproto.message_field(5) + id: int = betterproto.uint32_field(10) + lkefolcgfgd: "PFGAIEBGHCP" = betterproto.message_field(7) + nbkelchilgg: bool = betterproto.bool_field(399) + hp: int = betterproto.int32_field(8) + skill_id: int = betterproto.uint32_field(9) + max_hp: int = betterproto.int32_field(4) + fdndmhjohmo: "PFGAIEBGHCP" = betterproto.message_field(13) + pnldlmnkjmk: int = betterproto.uint32_field(1226) + ggbfkenahoe: float = betterproto.float_field(907) + dmbbmffejgi: bool = betterproto.bool_field(1846) + dhelbcimlga: int = betterproto.uint32_field(929) + + +@dataclass +class GLDNBPFCNHD(betterproto.Message): + pmanbplflkl: bool = betterproto.bool_field(13) + ainlmgdnhib: List["DCDNIAJCEHN"] = betterproto.message_field(302) + omkkpgfjhfe: bool = betterproto.bool_field(333) + ehcjcilcnop: int = betterproto.uint32_field(2) + hmffhgbkogl: int = betterproto.uint32_field(5) + hlieamplipp: List["DCDNIAJCEHN"] = betterproto.message_field(12) + dndjkdfhepe: "IMPKPKAMIAF" = betterproto.enum_field(11) + eefcbbkkflc: float = betterproto.float_field(3) + jldcflkcbld: List[int] = betterproto.uint32_field(15) + queue_position: int = betterproto.uint32_field(1) + dhelbcimlga: int = betterproto.uint32_field(10) + kjgdknjfcpg: int = betterproto.uint32_field(14) + nkhpckegpcl: int = betterproto.uint32_field(1095) + fombhjkdhgo: int = betterproto.uint32_field(1753) + knchehiijnn: List[int] = betterproto.uint32_field(8) + fmkdifnjajc: int = betterproto.uint32_field(9) + iepgclgkheg: int = betterproto.uint32_field(88) + extra_id: int = betterproto.uint32_field(7) + dpooapkpchf: List[int] = betterproto.uint32_field(4) + fjkbaimdpep: bool = betterproto.bool_field(6) + + +@dataclass +class MAOGFDKDCKM(betterproto.Message): + hmffhgbkogl: int = betterproto.uint32_field(6) + khcmofpfoak: "EOJLNGDDLNN" = betterproto.message_field(5) + lgpiemdlhjm: "LBAOGIBPJOP" = betterproto.message_field(9) + omkkpgfjhfe: bool = betterproto.bool_field(15) + iehfhkmdagc: int = betterproto.uint32_field(1) + dplgcekjack: float = betterproto.float_field(11) + olkmcbjflej: List["HBGHAOPBKJP"] = betterproto.message_field(2) + chllmfjgppa: int = betterproto.uint32_field(7) + phase: "PPIFFKJEJJA" = betterproto.enum_field(12) + dibpggoogpk: List["HBGHAOPBKJP"] = betterproto.message_field(10) + knchehiijnn: List[int] = betterproto.uint32_field(13) + bbdoplekiac: "EOJLNGDDLNN" = betterproto.message_field(3) + + +@dataclass +class GOCKGIGBDCG(betterproto.Message): + item_id: int = betterproto.uint32_field(5) + chllmfjgppa: int = betterproto.uint32_field(6) + kbcejinfnnj: "PFGAIEBGHCP" = betterproto.message_field(10) + + +@dataclass +class EOJLNGDDLNN(betterproto.Message): + cgnbhkbhicg: int = betterproto.uint32_field(15) + panbcnicohj: int = betterproto.uint32_field(13) + jfedjmkmlfo: List[int] = betterproto.uint32_field(4) + mdbggblegem: List["JALLAPPCPFE"] = betterproto.message_field(2) + blaljmmhifp: bool = betterproto.bool_field(9) + nbkelchilgg: bool = betterproto.bool_field(8) + nbkhpjhjmho: List["HBGHAOPBKJP"] = betterproto.message_field(6) + + +@dataclass +class HBGHAOPBKJP(betterproto.Message): + pmanbplflkl: bool = betterproto.bool_field(7) + fnihjjjgoee: "PFGAIEBGHCP" = betterproto.message_field(1) + bmnecpiopdn: bool = betterproto.bool_field(4) + mnbemgnnfod: float = betterproto.float_field(12) + level: int = betterproto.uint32_field(9) + hp: int = betterproto.int32_field(2) + plfkoccdbag: bool = betterproto.bool_field(15) + lkefolcgfgd: "PFGAIEBGHCP" = betterproto.message_field(13) + buff_id: int = betterproto.uint32_field(10) + id: int = betterproto.uint32_field(8) + jlcikblnenh: int = betterproto.uint32_field(5) + dmbbmffejgi: bool = betterproto.bool_field(14) + max_hp: int = betterproto.int32_field(3) + attack: int = betterproto.int32_field(11) + + +@dataclass +class JALLAPPCPFE(betterproto.Message): + dhelbcimlga: int = betterproto.uint32_field(7) + fhokfdmfnkg: bool = betterproto.bool_field(8) + + +@dataclass +class MEKDNIKFDNA(betterproto.Message): + ldnbeidjbhi: int = betterproto.uint32_field(2) + ognepbfpilh: int = betterproto.uint32_field(12) + rank: int = betterproto.uint32_field(6) + hp: int = betterproto.uint32_field(13) + nmlffogbpoc: int = betterproto.uint32_field(7) + score_id: int = betterproto.uint32_field(10) + state: "NPPNFPPENMC" = betterproto.enum_field(4) + hnjfffjdgne: bool = betterproto.bool_field(14) + + +@dataclass +class KLDMJEMIMCN(betterproto.Message): + jgibhfjmobe: "DGFCBOFAOIA" = betterproto.enum_field(5) + cpkpincceip: List["MEKDNIKFDNA"] = betterproto.message_field(3) + mejdmjikimo: "MDOHAFBEEPK" = betterproto.message_field(6) + danccaojljn: int = betterproto.uint32_field(10) + hcbbhckjnji: int = betterproto.int32_field(8) + hbanccokofc: List[int] = betterproto.uint32_field(1) + mcokhhfpbpj: int = betterproto.uint64_field(7) + + +@dataclass +class JJAEPDIHCNL(betterproto.Message): + heckmdlolag: int = betterproto.uint32_field(3) + fpbedncocho: int = betterproto.uint32_field(14) + + +@dataclass +class MDOHAFBEEPK(betterproto.Message): + pkdpiemgibe: int = betterproto.uint32_field(15) + cur_hp: int = betterproto.uint32_field(10) + kjpmohfiilo: "NPPNFPPENMC" = betterproto.enum_field(9) + anhfjkepcgf: int = betterproto.uint32_field(8) + najlpnlnoje: int = betterproto.uint32_field(6) + niaeghjlnmb: "CDIMEMFJJFP" = betterproto.message_field(7) + energy_info: int = betterproto.uint32_field(13) + score_id: int = betterproto.uint32_field(3) + midejnjcaia: int = betterproto.uint32_field(12) + gdfndpmjdaf: int = betterproto.uint32_field(1) + aihmghajgkj: List[int] = betterproto.uint32_field(11) + + +@dataclass +class EGCDDLKHFEB(betterproto.Message): + mlpcfgdafnd: "MDOHAFBEEPK" = betterproto.message_field(6) + olkndfjbdgj: "BFILLIOBMFN" = betterproto.enum_field(10) + + +@dataclass +class FightMatch3DataCsReq(betterproto.Message): + player_data: int = betterproto.int32_field(5) + + +@dataclass +class FightMatch3DataScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(7) + data: "KLDMJEMIMCN" = betterproto.message_field(2) + lipjdjpmokb: List["CBBDIOMIFHD"] = betterproto.message_field(6) + + +@dataclass +class FightMatch3StartCountDownScNotify(betterproto.Message): + data: "KLDMJEMIMCN" = betterproto.message_field(8) + + +@dataclass +class FightMatch3TurnStartScNotify(betterproto.Message): + hkpodflgcdj: "KLDMJEMIMCN" = betterproto.message_field(14) + + +@dataclass +class FightMatch3TurnEndScNotify(betterproto.Message): + cinlcmhhkko: "KLDMJEMIMCN" = betterproto.message_field(14) + hiklobgicmp: "KLDMJEMIMCN" = betterproto.message_field(1) + + +@dataclass +class FightMatch3SwapCsReq(betterproto.Message): + phnldpokbkl: "JJAEPDIHCNL" = betterproto.message_field(10) + cur_index: int = betterproto.uint32_field(7) + eckkblnelbm: List["EGCDDLKHFEB"] = betterproto.message_field(6) + feclglbfidh: "JJAEPDIHCNL" = betterproto.message_field(15) + + +@dataclass +class FightMatch3SwapScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(2) + cur_index: int = betterproto.uint32_field(5) + pgmgmjdilcl: bool = betterproto.bool_field(1) + chmaonmmegm: "MDOHAFBEEPK" = betterproto.message_field(13) + + +@dataclass +class FightMatch3OpponentDataScNotify(betterproto.Message): + state: "NPPNFPPENMC" = betterproto.enum_field(3) + score_id: int = betterproto.uint32_field(14) + nmlffogbpoc: int = betterproto.uint32_field(11) + hp: int = betterproto.uint32_field(12) + danccaojljn: int = betterproto.uint32_field(1) + + +@dataclass +class FightMatch3ChatCsReq(betterproto.Message): + habdkbfmkee: int = betterproto.uint32_field(9) + + +@dataclass +class FightMatch3ChatScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(12) + habdkbfmkee: int = betterproto.uint32_field(7) + + +@dataclass +class FightMatch3ChatScNotify(betterproto.Message): + egkpfgnjahn: int = betterproto.uint32_field(8) + habdkbfmkee: int = betterproto.uint32_field(1) + + +@dataclass +class FightMatch3ForceUpdateNotify(betterproto.Message): + data: "KLDMJEMIMCN" = betterproto.message_field(8) + + +@dataclass +class AssistSimpleInfo(betterproto.Message): + avatar_id: int = betterproto.uint32_field(3) + pos: int = betterproto.uint32_field(14) + dressed_skin_id: int = betterproto.uint32_field(2) + level: int = betterproto.uint32_field(1) + + +@dataclass +class IHKGNJDNALJ(betterproto.Message): + group_id: int = betterproto.uint32_field(6) + fccdilggoci: int = betterproto.uint32_field(7) + jgmipmdppij: int = betterproto.uint32_field(4) + khcnajokjhj: int = betterproto.uint32_field(5) + + +@dataclass +class KPIGLOPEMCF(betterproto.Message): + ijhlojefcpm: int = betterproto.uint32_field(12) + + +@dataclass +class PHHLIOGFDEK(betterproto.Message): + capiccciebo: List[int] = betterproto.uint32_field(15) + ijhlojefcpm: int = betterproto.uint32_field(1) + ofgbjcccike: int = betterproto.uint32_field(13) + + +@dataclass +class BCPDFIPOMAP(betterproto.Message): + lbhjehfjlnf: "PHHLIOGFDEK" = betterproto.message_field(6) + + +@dataclass +class OBIHNGMNKEK(betterproto.Message): + loonehfnapc: "KPIGLOPEMCF" = betterproto.message_field(14) + daopohamomf: "BCPDFIPOMAP" = betterproto.message_field(5) + + +@dataclass +class HIEJJBDNCNH(betterproto.Message): + eboomgdgnep: "IHKGNJDNALJ" = betterproto.message_field(8) + display_type: "BattleRecordType" = betterproto.enum_field(9) + jfpcpdcflmd: "OBIHNGMNKEK" = betterproto.message_field(3) + + +@dataclass +class PlayerSimpleInfo(betterproto.Message): + gmalcpnohbf: str = betterproto.string_field(2) + chat_bubble_id: int = betterproto.uint32_field(11) + head_icon: int = betterproto.uint32_field(15) + nickname: str = betterproto.string_field(4) + assist_simple_info_list: List["AssistSimpleInfo"] = betterproto.message_field(5) + platform: "PlatformType" = betterproto.enum_field(9) + anpllaobfji: int = betterproto.uint32_field(10) + last_active_time: int = betterproto.int64_field(8) + akcejfcfban: str = betterproto.string_field(6) + online_status: "FriendOnlineStatus" = betterproto.enum_field(3) + is_banned: bool = betterproto.bool_field(13) + signature: str = betterproto.string_field(12) + level: int = betterproto.uint32_field(14) + uid: int = betterproto.uint32_field(1) + + +@dataclass +class DisplayEquipmentInfo(betterproto.Message): + level: int = betterproto.uint32_field(13) + rank: int = betterproto.uint32_field(14) + tid: int = betterproto.uint32_field(10) + exp: int = betterproto.uint32_field(5) + promotion: int = betterproto.uint32_field(9) + + +@dataclass +class DisplayRelicInfo(betterproto.Message): + exp: int = betterproto.uint32_field(4) + main_affix_id: int = betterproto.uint32_field(6) + tid: int = betterproto.uint32_field(2) + sub_affix_list: List["RelicAffix"] = betterproto.message_field(9) + level: int = betterproto.uint32_field(1) + type: int = betterproto.uint32_field(14) + + +@dataclass +class DisplayAvatarDetailInfo(betterproto.Message): + exp: int = betterproto.uint32_field(6) + level: int = betterproto.uint32_field(12) + dressed_skin_id: int = betterproto.uint32_field(4) + relic_list: List["DisplayRelicInfo"] = betterproto.message_field(13) + pos: int = betterproto.uint32_field(3) + promotion: int = betterproto.uint32_field(14) + rank: int = betterproto.uint32_field(2) + avatar_id: int = betterproto.uint32_field(9) + equipment: "DisplayEquipmentInfo" = betterproto.message_field(10) + skilltree_list: List["AvatarSkillTree"] = betterproto.message_field(8) + + +@dataclass +class PlayerCollectionInfo(betterproto.Message): + pgcdmmnncjc: int = betterproto.uint32_field(10) + pjcjnkbeimk: int = betterproto.uint32_field(11) + nljifekdphn: int = betterproto.uint32_field(8) + ljpekedicml: int = betterproto.uint32_field(1) + bdbmikdjlko: int = betterproto.uint32_field(3) + + +@dataclass +class PlayerRecordInfo(betterproto.Message): + emjdebdmhll: int = betterproto.uint32_field(4) + bhfefeodnim: int = betterproto.uint32_field(6) + hknoakgcjbk: int = betterproto.uint32_field(7) + collection_info: "PlayerCollectionInfo" = betterproto.message_field(13) + cfdfmgllico: int = betterproto.uint32_field(2) + fhkkmpddmgo: int = betterproto.uint32_field(5) + ehbdeijjohk: int = betterproto.uint32_field(11) + gekkndonhlj: int = betterproto.uint32_field(3) + jfpgbkbpbnf: int = betterproto.uint32_field(14) + + +@dataclass +class PrivacySettings(betterproto.Message): + njfmiljofok: bool = betterproto.bool_field(4) + pbkbglhhkpe: bool = betterproto.bool_field(10) + kjncckhjfhe: bool = betterproto.bool_field(6) + aicnfaobcpi: bool = betterproto.bool_field(2) + aponeidmphl: bool = betterproto.bool_field(8) + + +@dataclass +class PlayerDisplaySettings(betterproto.Message): + challenge_list: List["IHKGNJDNALJ"] = betterproto.message_field(8) + jfpcpdcflmd: "OBIHNGMNKEK" = betterproto.message_field(7) + + +@dataclass +class PlayerDetailInfo(betterproto.Message): + head_icon: int = betterproto.uint32_field(4) + akcejfcfban: str = betterproto.string_field(13) + display_avatar_list: List["DisplayAvatarDetailInfo"] = betterproto.message_field(3) + emobijbdkei: bool = betterproto.bool_field(9) + is_banned: bool = betterproto.bool_field(5) + uid: int = betterproto.uint32_field(2) + privacy_settings: "PrivacySettings" = betterproto.message_field(863) + onkhlhojhgn: "PlayerDisplaySettings" = betterproto.message_field(361) + world_level: int = betterproto.uint32_field(12) + nickname: str = betterproto.string_field(8) + gmalcpnohbf: str = betterproto.string_field(15) + record_info: "PlayerRecordInfo" = betterproto.message_field(11) + level: int = betterproto.uint32_field(6) + kbmgbninfbk: int = betterproto.uint32_field(7) + assist_avatar_list: List["DisplayAvatarDetailInfo"] = betterproto.message_field( + 1517 + ) + platform: "PlatformType" = betterproto.enum_field(1) + anpllaobfji: int = betterproto.uint32_field(635) + signature: str = betterproto.string_field(10) + ooopbhimnfd: int = betterproto.uint32_field(14) + + +@dataclass +class FriendSimpleInfo(betterproto.Message): + playing_state: "PlayingState" = betterproto.enum_field(5) + create_time: int = betterproto.int64_field(14) + ilchajcffbf: "HIEJJBDNCNH" = betterproto.message_field(3) + remark_name: str = betterproto.string_field(12) + player_info: "PlayerSimpleInfo" = betterproto.message_field(6) + is_marked: bool = betterproto.bool_field(15) + + +@dataclass +class FriendApplyInfo(betterproto.Message): + player_info: "PlayerSimpleInfo" = betterproto.message_field(11) + apply_time: int = betterproto.int64_field(6) + + +@dataclass +class FriendRecommendInfo(betterproto.Message): + jholblpeglj: bool = betterproto.bool_field(11) + player_info: "PlayerSimpleInfo" = betterproto.message_field(5) + + +@dataclass +class PlayerAssistInfo(betterproto.Message): + player_info: "PlayerSimpleInfo" = betterproto.message_field(4) + mdhfanlhnma: "DisplayAvatarDetailInfo" = betterproto.message_field(10) + + +@dataclass +class FLCMJAHGKFK(betterproto.Message): + nppphgfenph: int = betterproto.uint32_field(10) + head_icon: int = betterproto.uint32_field(15) + level: int = betterproto.uint32_field(1) + innaniclcae: int = betterproto.uint32_field(4) + platform: "PlatformType" = betterproto.enum_field(13) + gmalcpnohbf: str = betterproto.string_field(8) + remark_name: str = betterproto.string_field(5) + nickname: str = betterproto.string_field(3) + uid: int = betterproto.uint32_field(2) + + +@dataclass +class FCNOLLFGPCK(betterproto.Message): + remark_name: str = betterproto.string_field(11) + buff_one: int = betterproto.uint32_field(2) + inhddnnpbdb: int = betterproto.uint32_field(3) + player_info: "PlayerSimpleInfo" = betterproto.message_field(9) + buff_two: int = betterproto.uint32_field(12) + lineup_list: List["ChallengeLineupList"] = betterproto.message_field(6) + score_id: int = betterproto.uint32_field(14) + + +@dataclass +class CHKIICNAPHA(betterproto.Message): + challenge_default: "ChallengeStatistics" = betterproto.message_field( + 172 + ) + challenge_story: "ChallengeStoryStatistics" = betterproto.message_field( + 847 + ) + challenge_boss: "ChallengeBossStatistics" = betterproto.message_field( + 1035 + ) + group_id: int = betterproto.uint32_field(1) + k_h_c_n_a_j_o_k_j_h_j: int = betterproto.uint32_field(7) + + +@dataclass +class OGNLDADPJFO(betterproto.Message): + rogue_finish_info: "RogueFinishInfo" = betterproto.message_field(13) + map_id: int = betterproto.uint32_field(8) + + +@dataclass +class EAIMKOMHKHD(betterproto.Message): + ggdiibcdobb: int = betterproto.uint32_field(15) + avatar_id: int = betterproto.uint32_field(5) + + +@dataclass +class ANGOAMADOMA(betterproto.Message): + ofgbjcccike: int = betterproto.uint32_field(2) + ijhlojefcpm: int = betterproto.uint32_field(7) + jbloklcpafn: int = betterproto.uint32_field(1) + tourn_finish_info: "RogueTournFinishInfo" = betterproto.message_field(5) + + +@dataclass +class GGKBHALPIDK(betterproto.Message): + lhbdonjiicc: int = betterproto.uint32_field(6) + area_id: int = betterproto.uint32_field(9) + imlhfgepcan: int = betterproto.uint32_field(13) + + +@dataclass +class LFJPDDCNBKC(betterproto.Message): + fjhigbbmjdm: int = betterproto.uint32_field(10) + area_id: int = betterproto.uint32_field(2) + fnmgaohmlim: int = betterproto.uint32_field(7) + epljmcapmpc: int = betterproto.uint32_field(13) + + +@dataclass +class NHAGPMMCDCF(betterproto.Message): + onahhamhfdb: int = betterproto.uint32_field(1) + agijkfbcjoc: int = betterproto.uint32_field(11) + area_id: int = betterproto.uint32_field(13) + oiajancbabp: int = betterproto.uint32_field(15) + + +@dataclass +class OKDBOGBABNI(betterproto.Message): + edgfedjbahf: "OGNLDADPJFO" = betterproto.message_field(788) + opfpolcgmed: "ANGOAMADOMA" = betterproto.message_field(130) + p_l_c_c_e_h_d_n_a_f_l: "GGKBHALPIDK" = betterproto.message_field(7) + h_d_l_j_b_a_d_e_k_f_i: "NHAGPMMCDCF" = betterproto.message_field(13) + a_p_m_j_f_g_k_i_f_o_n: "LFJPDDCNBKC" = betterproto.message_field(10) + + +@dataclass +class IOJHJAHIMHM(betterproto.Message): + area_id: int = betterproto.uint32_field(6) + + +@dataclass +class JIENKFADCHE(betterproto.Message): + area_id: int = betterproto.uint32_field(2) + njoiciopbnh: int = betterproto.uint32_field(15) + + +@dataclass +class MEEHCBGDBEA(betterproto.Message): + challenge_id: int = betterproto.uint32_field(3) + + +@dataclass +class DHAHAKMPNAF(betterproto.Message): + liibbggehfp: "IOJHJAHIMHM" = betterproto.message_field(1131) + ikffobamghj: "MEEHCBGDBEA" = betterproto.message_field(1838) + avatar_id: int = betterproto.uint32_field(793) + mdmgkhlhiin: int = betterproto.uint32_field(1661) + ckknnhmdcog: int = betterproto.uint32_field(75) + ielhlbffagk: "JIENKFADCHE" = betterproto.message_field(1433) + panel_id: int = betterproto.uint32_field(1901) + e_j_h_m_n_k_h_e_p_f_a: "DevelopmentType" = betterproto.enum_field(11) + time: int = betterproto.int64_field(10) + + +@dataclass +class GetFriendListInfoCsReq(betterproto.Message): + pass + + +@dataclass +class GetFriendListInfoScRsp(betterproto.Message): + friend_list: List["FriendSimpleInfo"] = betterproto.message_field(15) + black_list: List["PlayerSimpleInfo"] = betterproto.message_field(4) + retcode: int = betterproto.uint32_field(2) + + +@dataclass +class GetPlayerDetailInfoCsReq(betterproto.Message): + uid: int = betterproto.uint32_field(12) + + +@dataclass +class GetPlayerDetailInfoScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(4) + detail_info: "PlayerDetailInfo" = betterproto.message_field(11) + + +@dataclass +class GetFriendApplyListInfoCsReq(betterproto.Message): + pass + + +@dataclass +class GetFriendApplyListInfoScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(10) + receive_apply_list: List["FriendApplyInfo"] = betterproto.message_field(12) + send_apply_list: List[int] = betterproto.uint32_field(11) + + +@dataclass +class ApplyFriendCsReq(betterproto.Message): + uid: int = betterproto.uint32_field(14) + source: "FriendApplySource" = betterproto.enum_field(8) + + +@dataclass +class ApplyFriendScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(13) + uid: int = betterproto.uint32_field(2) + + +@dataclass +class SyncApplyFriendScNotify(betterproto.Message): + apply_info: "FriendApplyInfo" = betterproto.message_field(4) + + +@dataclass +class HandleFriendCsReq(betterproto.Message): + uid: int = betterproto.uint32_field(8) + is_accept: bool = betterproto.bool_field(2) + + +@dataclass +class HandleFriendScRsp(betterproto.Message): + is_accept: bool = betterproto.bool_field(1) + uid: int = betterproto.uint32_field(12) + retcode: int = betterproto.uint32_field(2) + friend_info: "FriendSimpleInfo" = betterproto.message_field(3) + + +@dataclass +class SyncHandleFriendScNotify(betterproto.Message): + is_accept: bool = betterproto.bool_field(11) + uid: int = betterproto.uint32_field(14) + friend_info: "FriendSimpleInfo" = betterproto.message_field(5) + + +@dataclass +class DeleteFriendCsReq(betterproto.Message): + fiocdbipcgb: int = betterproto.uint32_field(8) + uid: int = betterproto.uint32_field(15) + + +@dataclass +class DeleteFriendScRsp(betterproto.Message): + uid: int = betterproto.uint32_field(7) + retcode: int = betterproto.uint32_field(12) + + +@dataclass +class SyncDeleteFriendScNotify(betterproto.Message): + uid: int = betterproto.uint32_field(15) + + +@dataclass +class AddBlacklistCsReq(betterproto.Message): + uid: int = betterproto.uint32_field(3) + + +@dataclass +class AddBlacklistScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(7) + black_info: "PlayerSimpleInfo" = betterproto.message_field(6) + + +@dataclass +class SyncAddBlacklistScNotify(betterproto.Message): + uid: int = betterproto.uint32_field(9) + + +@dataclass +class GetFriendRecommendListInfoCsReq(betterproto.Message): + ahoilnfiieg: bool = betterproto.bool_field(12) + + +@dataclass +class GetFriendRecommendListInfoScRsp(betterproto.Message): + player_info_list: List["FriendRecommendInfo"] = betterproto.message_field(15) + retcode: int = betterproto.uint32_field(11) + + +@dataclass +class SetFriendRemarkNameCsReq(betterproto.Message): + reason: int = betterproto.uint32_field(2) + uid: int = betterproto.uint32_field(5) + remark_name: str = betterproto.string_field(11) + + +@dataclass +class SetFriendRemarkNameScRsp(betterproto.Message): + remark_name: str = betterproto.string_field(8) + uid: int = betterproto.uint32_field(3) + retcode: int = betterproto.uint32_field(10) + + +@dataclass +class ReportPlayerCsReq(betterproto.Message): + mimakhaabah: str = betterproto.string_field(2) + ehbcljfpooe: int = betterproto.uint32_field(7) + uid: int = betterproto.uint32_field(5) + + +@dataclass +class ReportPlayerScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(9) + + +@dataclass +class DeleteBlacklistCsReq(betterproto.Message): + uid: int = betterproto.uint32_field(4) + + +@dataclass +class DeleteBlacklistScRsp(betterproto.Message): + uid: int = betterproto.uint32_field(9) + retcode: int = betterproto.uint32_field(3) + + +@dataclass +class SearchPlayerCsReq(betterproto.Message): + uid_list: List[int] = betterproto.uint32_field(5) + ahoilnfiieg: bool = betterproto.bool_field(9) + + +@dataclass +class SearchPlayerScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(6) + result_uid_list: List[int] = betterproto.uint32_field(4) + simple_info_list: List["PlayerSimpleInfo"] = betterproto.message_field(12) + + +@dataclass +class GetAssistListCsReq(betterproto.Message): + kiboagmojcp: bool = betterproto.bool_field(13) + ahoilnfiieg: bool = betterproto.bool_field(7) + + +@dataclass +class GetAssistListScRsp(betterproto.Message): + assist_list: List["PlayerAssistInfo"] = betterproto.message_field(1) + retcode: int = betterproto.uint32_field(14) + + +@dataclass +class SetAssistCsReq(betterproto.Message): + uid: int = betterproto.uint32_field(4) + avatar_id: int = betterproto.uint32_field(3) + + +@dataclass +class SetAssistScRsp(betterproto.Message): + avatar_id: int = betterproto.uint32_field(10) + uid: int = betterproto.uint32_field(11) + retcode: int = betterproto.uint32_field(7) + + +@dataclass +class GetCurAssistCsReq(betterproto.Message): + pass + + +@dataclass +class GetCurAssistScRsp(betterproto.Message): + assist_info: "PlayerAssistInfo" = betterproto.message_field(1) + retcode: int = betterproto.uint32_field(15) + + +@dataclass +class GetAssistHistoryCsReq(betterproto.Message): + pass + + +@dataclass +class GetAssistHistoryScRsp(betterproto.Message): + omhchjlliif: int = betterproto.uint32_field(5) + today_use_uid_list: List[int] = betterproto.uint32_field(8) + nfjjapnppkp: int = betterproto.uint32_field(2) + pbfneigopmp: int = betterproto.uint32_field(10) + retcode: int = betterproto.uint32_field(13) + + +@dataclass +class NewAssistHistoryNotify(betterproto.Message): + nfjjapnppkp: int = betterproto.uint32_field(14) + + +@dataclass +class TakeAssistRewardCsReq(betterproto.Message): + pass + + +@dataclass +class TakeAssistRewardScRsp(betterproto.Message): + nlcnbiehcoh: List["FLCMJAHGKFK"] = betterproto.message_field(11) + reward: "ItemList" = betterproto.message_field(7) + retcode: int = betterproto.uint32_field(10) + + +@dataclass +class CurAssistChangedNotify(betterproto.Message): + assist_info: "PlayerAssistInfo" = betterproto.message_field(7) + + +@dataclass +class GetPlatformPlayerInfoCsReq(betterproto.Message): + platform: "PlatformType" = betterproto.enum_field(10) + dnenlchjekg: List[str] = betterproto.string_field(14) + + +@dataclass +class GetPlatformPlayerInfoScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(9) + player_info_list: List["PlayerSimpleInfo"] = betterproto.message_field(11) + + +@dataclass +class GetFriendLoginInfoCsReq(betterproto.Message): + pass + + +@dataclass +class GetFriendLoginInfoScRsp(betterproto.Message): + dbndomdmmgf: List[int] = betterproto.uint32_field(15) + bohnbjmmkbo: bool = betterproto.bool_field(14) + retcode: int = betterproto.uint32_field(1) + iihdbinopmg: List[int] = betterproto.uint32_field(5) + lifcehlfdnm: bool = betterproto.bool_field(3) + + +@dataclass +class SetForbidOtherApplyFriendCsReq(betterproto.Message): + mjpflikafej: bool = betterproto.bool_field(15) + + +@dataclass +class SetForbidOtherApplyFriendScRsp(betterproto.Message): + mjpflikafej: bool = betterproto.bool_field(12) + retcode: int = betterproto.uint32_field(1) + + +@dataclass +class SetFriendMarkCsReq(betterproto.Message): + adjgkcokoln: bool = betterproto.bool_field(6) + uid: int = betterproto.uint32_field(2) + reason: int = betterproto.uint32_field(4) + + +@dataclass +class SetFriendMarkScRsp(betterproto.Message): + uid: int = betterproto.uint32_field(1) + retcode: int = betterproto.uint32_field(13) + adjgkcokoln: bool = betterproto.bool_field(14) + + +@dataclass +class GetFriendAssistListCsReq(betterproto.Message): + kcpaodebjdg: List[int] = betterproto.uint32_field(2) + mloogabmihp: "AssistAvatarType" = betterproto.enum_field(1) + target_side: int = betterproto.uint32_field(8) + ahoilnfiieg: bool = betterproto.bool_field(9) + bijgjecjmhm: List[int] = betterproto.uint32_field(6) + + +@dataclass +class GetFriendAssistListScRsp(betterproto.Message): + target_side: int = betterproto.uint32_field(14) + retcode: int = betterproto.uint32_field(9) + assist_list: List["PlayerAssistInfo"] = betterproto.message_field(8) + + +@dataclass +class GetFriendChallengeLineupCsReq(betterproto.Message): + challenge_id: int = betterproto.uint32_field(15) + + +@dataclass +class GetFriendChallengeLineupScRsp(betterproto.Message): + onocjeebfci: bool = betterproto.bool_field(1) + challenge_recommend_list: List["FCNOLLFGPCK"] = betterproto.message_field(11) + retcode: int = betterproto.uint32_field(7) + + +@dataclass +class GetFriendChallengeDetailCsReq(betterproto.Message): + uid: int = betterproto.uint32_field(3) + challenge_id: int = betterproto.uint32_field(6) + + +@dataclass +class GetFriendChallengeDetailScRsp(betterproto.Message): + uid: int = betterproto.uint32_field(6) + retcode: int = betterproto.uint32_field(10) + challenge_id: int = betterproto.uint32_field(14) + ccgdmoolhhb: List["DisplayAvatarDetailInfo"] = betterproto.message_field(4) + + +@dataclass +class KAMCIOPBPGA(betterproto.Message): + remark_name: str = betterproto.string_field(9) + avatar_list: List["OILPIACENNH"] = betterproto.message_field(4) + player_info: "PlayerSimpleInfo" = betterproto.message_field(2) + jhiakmchplb: List[int] = betterproto.uint32_field(13) + + +@dataclass +class KEHMGKIHEFN(betterproto.Message): + gieidjeepac: "FCNOLLFGPCK" = betterproto.message_field(5) + addcjejpfef: "KAMCIOPBPGA" = betterproto.message_field(10) + + +@dataclass +class IDNHIELAIFM(betterproto.Message): + key: int = betterproto.uint32_field(3) + type: "DLLLEANDAIH" = betterproto.enum_field(13) + + +@dataclass +class PCAPDIPOLMC(betterproto.Message): + key: int = betterproto.uint32_field(6) + retcode: int = betterproto.uint32_field(7) + onocjeebfci: bool = betterproto.bool_field(14) + challenge_recommend_list: List["KEHMGKIHEFN"] = betterproto.message_field(10) + type: "DLLLEANDAIH" = betterproto.enum_field(8) + + +@dataclass +class HHIOHFKOCFD(betterproto.Message): + uid: int = betterproto.uint32_field(13) + type: "DLLLEANDAIH" = betterproto.enum_field(9) + key: int = betterproto.uint32_field(4) + + +@dataclass +class CLCGHILDELA(betterproto.Message): + uid: int = betterproto.uint32_field(10) + ccgdmoolhhb: List["DisplayAvatarDetailInfo"] = betterproto.message_field(7) + key: int = betterproto.uint32_field(9) + retcode: int = betterproto.uint32_field(15) + type: "DLLLEANDAIH" = betterproto.enum_field(6) + + +@dataclass +class GetFriendBattleRecordDetailCsReq(betterproto.Message): + uid: int = betterproto.uint32_field(13) + + +@dataclass +class GetFriendBattleRecordDetailScRsp(betterproto.Message): + uid: int = betterproto.uint32_field(8) + retcode: int = betterproto.uint32_field(9) + pgbbepkahbh: "OKDBOGBABNI" = betterproto.message_field(7) + jdidihobaod: List["CHKIICNAPHA"] = betterproto.message_field(12) + + +@dataclass +class GetFriendDevelopmentInfoCsReq(betterproto.Message): + uid: int = betterproto.uint32_field(10) + + +@dataclass +class GetFriendDevelopmentInfoScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(15) + uid: int = betterproto.uint32_field(5) + jbhbfbjgbph: List["DHAHAKMPNAF"] = betterproto.message_field(9) + + +@dataclass +class GetGachaInfoCsReq(betterproto.Message): + pass + + +@dataclass +class GachaCeilingAvatar(betterproto.Message): + avatar_id: int = betterproto.uint32_field(15) + repeated_cnt: int = betterproto.uint32_field(4) + + +@dataclass +class GachaCeiling(betterproto.Message): + avatar_list: List["GachaCeilingAvatar"] = betterproto.message_field(13) + ceiling_num: int = betterproto.uint32_field(9) + is_claimed: bool = betterproto.bool_field(7) + + +@dataclass +class LOPDJAHFPHN(betterproto.Message): + chdoibfehlp: int = betterproto.uint32_field(11) + jigonealcpc: List[int] = betterproto.uint32_field(9) + iincdjpoomc: int = betterproto.uint32_field(5) + dlabdnpihff: List[int] = betterproto.uint32_field(10) + + +@dataclass +class GachaInfo(betterproto.Message): + detail_webview: str = betterproto.string_field(15) + prize_item_list: List[int] = betterproto.uint32_field(12) + drop_history_webview: str = betterproto.string_field(5) + gacha_ceiling: "GachaCeiling" = betterproto.message_field(8) + gacha_id: int = betterproto.uint32_field(1) + gdpoeejnmhn: "LOPDJAHFPHN" = betterproto.message_field(3) + end_time: int = betterproto.int64_field(10) + gdifaahifbh: int = betterproto.uint32_field(14) + kmnjnmjfgbg: int = betterproto.uint32_field(11) + begin_time: int = betterproto.int64_field(4) + item_detail_list: List[int] = betterproto.uint32_field(7) + + +@dataclass +class GetGachaInfoScRsp(betterproto.Message): + djndmnpebka: int = betterproto.uint32_field(9) + nbelnoipoek: int = betterproto.uint32_field(4) + gacha_info_list: List["GachaInfo"] = betterproto.message_field(1) + retcode: int = betterproto.uint32_field(14) + nopbebkhika: int = betterproto.uint32_field(12) + gacha_random: int = betterproto.uint32_field(3) + + +@dataclass +class DoGachaCsReq(betterproto.Message): + gacha_id: int = betterproto.uint32_field(7) + simulate_magic: int = betterproto.uint32_field(4) + gacha_random: int = betterproto.uint32_field(1) + gacha_num: int = betterproto.uint32_field(6) + + +@dataclass +class GachaItem(betterproto.Message): + token_item: "ItemList" = betterproto.message_field(7) + is_new: bool = betterproto.bool_field(3) + transfer_item_list: "ItemList" = betterproto.message_field(1) + gacha_item: "Item" = betterproto.message_field(14) + + +@dataclass +class DoGachaScRsp(betterproto.Message): + gacha_id: int = betterproto.uint32_field(6) + ceiling_num: int = betterproto.uint32_field(3) + gacha_item_list: List["GachaItem"] = betterproto.message_field(1) + gdifaahifbh: int = betterproto.uint32_field(14) + kmnjnmjfgbg: int = betterproto.uint32_field(4) + penilhglhhm: int = betterproto.uint32_field(13) + retcode: int = betterproto.uint32_field(5) + nopbebkhika: int = betterproto.uint32_field(12) + gacha_num: int = betterproto.uint32_field(7) + + +@dataclass +class GetGachaCeilingCsReq(betterproto.Message): + gacha_type: int = betterproto.uint32_field(1) + + +@dataclass +class GetGachaCeilingScRsp(betterproto.Message): + gacha_type: int = betterproto.uint32_field(1) + gacha_ceiling: "GachaCeiling" = betterproto.message_field(13) + retcode: int = betterproto.uint32_field(9) + + +@dataclass +class ExchangeGachaCeilingCsReq(betterproto.Message): + avatar_id: int = betterproto.uint32_field(15) + gacha_type: int = betterproto.uint32_field(8) + + +@dataclass +class ExchangeGachaCeilingScRsp(betterproto.Message): + gacha_type: int = betterproto.uint32_field(5) + transfer_item_list: "ItemList" = betterproto.message_field(15) + gacha_ceiling: "GachaCeiling" = betterproto.message_field(14) + avatar_id: int = betterproto.uint32_field(6) + retcode: int = betterproto.uint32_field(3) + + +@dataclass +class SetGachaDecideItemCsReq(betterproto.Message): + dlabdnpihff: List[int] = betterproto.uint32_field(4) + gacha_id: int = betterproto.uint32_field(8) + chdoibfehlp: int = betterproto.uint32_field(7) + + +@dataclass +class SetGachaDecideItemScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(8) + gdpoeejnmhn: "LOPDJAHFPHN" = betterproto.message_field(7) + farm_stage_gacha_id_list: List[int] = betterproto.uint32_field(4) + + +@dataclass +class GachaDecideItemChangeScNotify(betterproto.Message): + gdpoeejnmhn: "LOPDJAHFPHN" = betterproto.message_field(7) + farm_stage_gacha_id_list: List[int] = betterproto.uint32_field(2) + + +@dataclass +class HeartDialDialogueInfo(betterproto.Message): + dialogue_id: int = betterproto.uint32_field(6) + fbkekcgelbe: bool = betterproto.bool_field(4) + + +@dataclass +class HeartDialScriptInfo(betterproto.Message): + kkgfigchkib: bool = betterproto.bool_field(14) + cur_emotion_type: "HeartDialEmotionType" = betterproto.enum_field(13) + step: "HeartDialStepType" = betterproto.enum_field(8) + jmpejfickjo: bool = betterproto.bool_field(12) + script_id: int = betterproto.uint32_field(2) + + +@dataclass +class MMEINFMDJFG(betterproto.Message): + kbmmmmckjni: int = betterproto.uint32_field(7) + script_id: int = betterproto.uint32_field(13) + + +@dataclass +class GetHeartDialInfoCsReq(betterproto.Message): + pass + + +@dataclass +class GetHeartDialInfoScRsp(betterproto.Message): + unlock_status: "HeartDialUnlockStatus" = betterproto.enum_field(6) + ocmoejidlam: List["MMEINFMDJFG"] = betterproto.message_field(3) + retcode: int = betterproto.uint32_field(4) + script_info_list: List["HeartDialScriptInfo"] = betterproto.message_field(11) + dialogue_info_list: List["HeartDialDialogueInfo"] = betterproto.message_field(10) + + +@dataclass +class ChangeScriptEmotionCsReq(betterproto.Message): + fihncoabela: int = betterproto.uint32_field(9) + target_emotion_type: "HeartDialEmotionType" = betterproto.enum_field(6) + script_id: int = betterproto.uint32_field(11) + + +@dataclass +class ChangeScriptEmotionScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(5) + emotion_type: "HeartDialEmotionType" = betterproto.enum_field(9) + script_id: int = betterproto.uint32_field(11) + + +@dataclass +class SubmitEmotionItemCsReq(betterproto.Message): + script_id: int = betterproto.uint32_field(12) + item_list: "ItemList" = betterproto.message_field(5) + fihncoabela: int = betterproto.uint32_field(10) + + +@dataclass +class SubmitEmotionItemScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(5) + script_id: int = betterproto.uint32_field(15) + + +@dataclass +class FinishEmotionDialoguePerformanceCsReq(betterproto.Message): + script_id: int = betterproto.uint32_field(5) + fihncoabela: int = betterproto.uint32_field(6) + dialogue_id: int = betterproto.uint32_field(12) + + +@dataclass +class FinishEmotionDialoguePerformanceScRsp(betterproto.Message): + script_id: int = betterproto.uint32_field(13) + dialogue_id: int = betterproto.uint32_field(14) + retcode: int = betterproto.uint32_field(3) + reward_list: "ItemList" = betterproto.message_field(5) + + +@dataclass +class HeartDialScriptChangeScNotify(betterproto.Message): + changed_script_info_list: List["HeartDialScriptInfo"] = betterproto.message_field(3) + unlock_status: "HeartDialUnlockStatus" = betterproto.enum_field(7) + changed_dialogue_info_list: List["HeartDialDialogueInfo"] = ( + betterproto.message_field(12) + ) + ocmoejidlam: List["MMEINFMDJFG"] = betterproto.message_field(9) + + +@dataclass +class HeartDialTraceScriptCsReq(betterproto.Message): + agoipfbddpo: "MMEINFMDJFG" = betterproto.message_field(12) + + +@dataclass +class HeartDialTraceScriptScRsp(betterproto.Message): + agoipfbddpo: "MMEINFMDJFG" = betterproto.message_field(7) + retcode: int = betterproto.uint32_field(6) + + +@dataclass +class DEJAKPOEPKN(betterproto.Message): + cgfgfmgdpnj: int = betterproto.uint32_field(13) + lfpmaobgnen: List[int] = betterproto.uint32_field(2) + + +@dataclass +class JMIJJHKIBLB(betterproto.Message): + challenge_id: int = betterproto.uint32_field(15) + star: int = betterproto.uint32_field(4) + gjieahdbnni: bool = betterproto.bool_field(12) + + +@dataclass +class HeliobusChallengeLineup(betterproto.Message): + avatar_id_list: List[int] = betterproto.uint32_field(9) + group_id: int = betterproto.uint32_field(5) + skill_id: int = betterproto.uint32_field(7) + + +@dataclass +class HeliobusActivityDataCsReq(betterproto.Message): + pass + + +@dataclass +class HeliobusActivityDataScRsp(betterproto.Message): + level: int = betterproto.uint32_field(3) + retcode: int = betterproto.uint32_field(10) + gcljengjicm: List["HeliobusChallengeLineup"] = betterproto.message_field(14) + phase: int = betterproto.uint32_field(6) + challenge_list: List["JMIJJHKIBLB"] = betterproto.message_field(4) + eenjbpmndol: int = betterproto.uint32_field(2) + ibhaaejeehc: int = betterproto.uint32_field(1) + iphkdelmoih: int = betterproto.uint32_field(8) + nfdbmhppfip: List["GBJKKFHPFFN"] = betterproto.message_field(5) + skill_info: "DEJAKPOEPKN" = betterproto.message_field(9) + + +@dataclass +class GOAMMAGCIJJ(betterproto.Message): + kmaempmoccc: int = betterproto.uint32_field(10) + eliadkdaeco: int = betterproto.uint32_field(9) + jndkooejcfc: List["GOAMMAGCIJJ"] = betterproto.message_field(7) + + +@dataclass +class GBJKKFHPFFN(betterproto.Message): + jfmofiidcnp: int = betterproto.uint32_field(10) + ihkejebceib: int = betterproto.uint32_field(14) + ajciodkllml: bool = betterproto.bool_field(2) + cmhgbbhknci: int = betterproto.uint32_field(4) + fclnoogehmc: int = betterproto.uint32_field(3) + ndjfnhfpcgd: List["GOAMMAGCIJJ"] = betterproto.message_field(9) + dekhdibcfab: bool = betterproto.bool_field(6) + aknkpkpljhf: int = betterproto.uint32_field(15) + + +@dataclass +class HeliobusSnsReadCsReq(betterproto.Message): + ihkejebceib: int = betterproto.uint32_field(5) + + +@dataclass +class HeliobusSnsReadScRsp(betterproto.Message): + ihkejebceib: int = betterproto.uint32_field(11) + retcode: int = betterproto.uint32_field(15) + + +@dataclass +class HeliobusSnsPostCsReq(betterproto.Message): + fclnoogehmc: int = betterproto.uint32_field(12) + ihkejebceib: int = betterproto.uint32_field(14) + jfmofiidcnp: int = betterproto.uint32_field(11) + + +@dataclass +class HeliobusSnsPostScRsp(betterproto.Message): + eimcnifmlbl: "GBJKKFHPFFN" = betterproto.message_field(12) + retcode: int = betterproto.uint32_field(6) + + +@dataclass +class HeliobusSnsLikeCsReq(betterproto.Message): + ihkejebceib: int = betterproto.uint32_field(3) + + +@dataclass +class HeliobusSnsLikeScRsp(betterproto.Message): + ihkejebceib: int = betterproto.uint32_field(11) + retcode: int = betterproto.uint32_field(2) + dekhdibcfab: bool = betterproto.bool_field(14) + + +@dataclass +class HeliobusSnsCommentCsReq(betterproto.Message): + kaljkfkjffa: int = betterproto.uint32_field(4) + ihkejebceib: int = betterproto.uint32_field(2) + kmaempmoccc: int = betterproto.uint32_field(7) + + +@dataclass +class HeliobusSnsCommentScRsp(betterproto.Message): + eimcnifmlbl: "GBJKKFHPFFN" = betterproto.message_field(2) + retcode: int = betterproto.uint32_field(6) + + +@dataclass +class HeliobusSnsUpdateScNotify(betterproto.Message): + gkfhmgmbika: List["GBJKKFHPFFN"] = betterproto.message_field(3) + + +@dataclass +class HeliobusInfoChangedScNotify(betterproto.Message): + gkfhmgmbika: List["GBJKKFHPFFN"] = betterproto.message_field(2) + iphkdelmoih: int = betterproto.uint32_field(13) + phase: int = betterproto.uint32_field(10) + eenjbpmndol: int = betterproto.uint32_field(8) + + +@dataclass +class HeliobusUpgradeLevelCsReq(betterproto.Message): + pass + + +@dataclass +class HeliobusUpgradeLevelScRsp(betterproto.Message): + level: int = betterproto.uint32_field(15) + retcode: int = betterproto.uint32_field(1) + + +@dataclass +class HeliobusUnlockSkillScNotify(betterproto.Message): + skill_id: int = betterproto.uint32_field(10) + cgfgfmgdpnj: int = betterproto.uint32_field(3) + + +@dataclass +class HeliobusEnterBattleCsReq(betterproto.Message): + event_id: int = betterproto.uint32_field(10) + avatar_id_list: List[int] = betterproto.uint32_field(12) + skill_id: int = betterproto.uint32_field(13) + + +@dataclass +class HeliobusEnterBattleScRsp(betterproto.Message): + battle_info: "SceneBattleInfo" = betterproto.message_field(15) + event_id: int = betterproto.uint32_field(3) + retcode: int = betterproto.uint32_field(14) + + +@dataclass +class HeliobusSelectSkillCsReq(betterproto.Message): + skill_id: int = betterproto.uint32_field(7) + + +@dataclass +class HeliobusSelectSkillScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(12) + skill_id: int = betterproto.uint32_field(13) + + +@dataclass +class HeliobusChallengeUpdateScNotify(betterproto.Message): + challenge: "JMIJJHKIBLB" = betterproto.message_field(11) + + +@dataclass +class HeliobusLineupUpdateScNotify(betterproto.Message): + lineup: "HeliobusChallengeLineup" = betterproto.message_field(3) + + +@dataclass +class HeliobusStartRaidCsReq(betterproto.Message): + enlknpiblio: int = betterproto.uint32_field(7) + avatar_list: List[int] = betterproto.uint32_field(1) + skill_id: int = betterproto.uint32_field(2) + raid_id: int = betterproto.uint32_field(10) + is_save: bool = betterproto.bool_field(3) + prop_entity_id: int = betterproto.uint32_field(13) + + +@dataclass +class HeliobusStartRaidScRsp(betterproto.Message): + scene: "FNLGPLNCPCL" = betterproto.message_field(15) + retcode: int = betterproto.uint32_field(5) + + +@dataclass +class GetBagCsReq(betterproto.Message): + pass + + +@dataclass +class Equipment(betterproto.Message): + level: int = betterproto.uint32_field(14) + unique_id: int = betterproto.uint32_field(8) + rank: int = betterproto.uint32_field(6) + dress_avatar_id: int = betterproto.uint32_field(1) + is_protected: bool = betterproto.bool_field(5) + tid: int = betterproto.uint32_field(7) + promotion: int = betterproto.uint32_field(12) + exp: int = betterproto.uint32_field(9) + + +@dataclass +class Relic(betterproto.Message): + exp: int = betterproto.uint32_field(1) + is_protected: bool = betterproto.bool_field(10) + tid: int = betterproto.uint32_field(6) + dress_avatar_id: int = betterproto.uint32_field(8) + unique_id: int = betterproto.uint32_field(5) + main_affix_id: int = betterproto.uint32_field(3) + is_discarded: bool = betterproto.bool_field(2) + reforge_sub_affix_list: List["RelicAffix"] = betterproto.message_field(14) + sub_affix_list: List["RelicAffix"] = betterproto.message_field(4) + level: int = betterproto.uint32_field(12) + + +@dataclass +class Material(betterproto.Message): + expire_time: int = betterproto.uint64_field(9) + num: int = betterproto.uint32_field(12) + tid: int = betterproto.uint32_field(10) + + +@dataclass +class WaitDelResource(betterproto.Message): + tid: int = betterproto.uint32_field(10) + num: int = betterproto.uint32_field(7) + + +@dataclass +class Material0(betterproto.Message): + num: int = betterproto.uint32_field(15) + expire_time: int = betterproto.uint64_field(5) + tid: int = betterproto.uint32_field(7) + + +@dataclass +class GetBagScRsp(betterproto.Message): + bafebhdobfj: List["PileItem"] = betterproto.message_field(5) + fcokffeapmi: List["Material0"] = betterproto.message_field(4) + material_list: List["Material"] = betterproto.message_field(12) + kmjefmfblli: List["TurnFoodSwitch"] = betterproto.enum_field(9) + ifenmdpbnkg: List["Material"] = betterproto.message_field(6) + equipment_list: List["Equipment"] = betterproto.message_field(8) + relic_list: List["Relic"] = betterproto.message_field(2) + aoiihcfmfph: List[int] = betterproto.uint32_field(1) + gemcacjlpij: List[int] = betterproto.uint32_field(10) + fdbjlgdhcdo: List[int] = betterproto.uint32_field(7) + retcode: int = betterproto.uint32_field(3) + aepnidponkc: int = betterproto.uint32_field(15) + wait_del_resource_list: List["WaitDelResource"] = betterproto.message_field(11) + phngmeljkbe: List["Material0"] = betterproto.message_field(13) + + +@dataclass +class PromoteEquipmentCsReq(betterproto.Message): + equipment_unique_id: int = betterproto.uint32_field(13) + cost_data: "ItemCostData" = betterproto.message_field(12) + + +@dataclass +class PromoteEquipmentScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(15) + + +@dataclass +class LockEquipmentCsReq(betterproto.Message): + odldpkioeom: List[int] = betterproto.uint32_field(2) + is_locked: bool = betterproto.bool_field(4) + + +@dataclass +class LockEquipmentScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(12) + + +@dataclass +class UseItemCsReq(betterproto.Message): + base_avatar_id: int = betterproto.uint32_field(1) + optional_reward_id: int = betterproto.uint32_field(15) + felciemkcgf: bool = betterproto.bool_field(6) + use_item_id: int = betterproto.uint32_field(8) + use_avatar_type: "AvatarType" = betterproto.enum_field(9) + use_item_count: int = betterproto.uint32_field(13) + + +@dataclass +class UseItemScRsp(betterproto.Message): + return_data: "ItemList" = betterproto.message_field(9) + month_card_out_date_time: int = betterproto.uint64_field(1) + use_item_id: int = betterproto.uint32_field(8) + retcode: int = betterproto.uint32_field(13) + use_item_count: int = betterproto.uint32_field(10) + formula_id: int = betterproto.uint32_field(3) + + +@dataclass +class RankUpEquipmentCsReq(betterproto.Message): + cost_data: "ItemCostData" = betterproto.message_field(8) + equipment_unique_id: int = betterproto.uint32_field(5) + + +@dataclass +class RankUpEquipmentScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(8) + + +@dataclass +class BEPAHBKLJNN(betterproto.Message): + equipment_unique_id: int = betterproto.uint32_field(12) + cost_data: "ItemCostData" = betterproto.message_field(9) + + +@dataclass +class BatchRankUpEquipmentCsReq(betterproto.Message): + switch_list: List["BEPAHBKLJNN"] = betterproto.message_field(15) + + +@dataclass +class BatchRankUpEquipmentScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(6) + + +@dataclass +class ExpUpEquipmentCsReq(betterproto.Message): + cost_data: "ItemCostData" = betterproto.message_field(2) + equipment_unique_id: int = betterproto.uint32_field(11) + + +@dataclass +class ExpUpEquipmentScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(5) + return_item_list: List["PileItem"] = betterproto.message_field(2) + + +@dataclass +class ComposeItemCsReq(betterproto.Message): + compose_item_list: "ItemCostData" = betterproto.message_field(12) + compose_id: int = betterproto.uint32_field(1) + count: int = betterproto.uint32_field(4) + convert_item_list: "ItemCostData" = betterproto.message_field(5) + + +@dataclass +class ComposeItemScRsp(betterproto.Message): + count: int = betterproto.uint32_field(12) + compose_id: int = betterproto.uint32_field(8) + retcode: int = betterproto.uint32_field(14) + return_item_list: "ItemList" = betterproto.message_field(5) + + +@dataclass +class ComposeSelectedRelicCsReq(betterproto.Message): + compose_relic_id: int = betterproto.uint32_field(13) + sub_affix_id_list: List[int] = betterproto.uint32_field(3) + main_affix_id: int = betterproto.uint32_field(2) + compose_item_list: "ItemCostData" = betterproto.message_field(11) + wr_item_list: "ItemCostData" = betterproto.message_field(10) + count: int = betterproto.uint32_field(15) + compose_id: int = betterproto.uint32_field(4) + + +@dataclass +class ComposeSelectedRelicScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(9) + return_item_list: "ItemList" = betterproto.message_field(2) + compose_id: int = betterproto.uint32_field(14) + + +@dataclass +class ExpUpRelicCsReq(betterproto.Message): + cost_data: "ItemCostData" = betterproto.message_field(1) + relic_unique_id: int = betterproto.uint32_field(2) + + +@dataclass +class ExpUpRelicScRsp(betterproto.Message): + return_item_list: List["PileItem"] = betterproto.message_field(3) + retcode: int = betterproto.uint32_field(12) + + +@dataclass +class LockRelicCsReq(betterproto.Message): + iemnpgomjco: bool = betterproto.bool_field(3) + is_locked: bool = betterproto.bool_field(8) + relic_ids: List[int] = betterproto.uint32_field(10) + + +@dataclass +class LockRelicScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(14) + + +@dataclass +class DiscardRelicCsReq(betterproto.Message): + jnkhgfiljpb: bool = betterproto.bool_field(11) + hnhfdmdibio: int = betterproto.uint64_field(6) + relic_ids: List[int] = betterproto.uint32_field(4) + nlpconnjonf: "ICPINEHOLML" = betterproto.enum_field(1) + + +@dataclass +class DiscardRelicScRsp(betterproto.Message): + relic_ids: List[int] = betterproto.uint32_field(1) + nlpconnjonf: "ICPINEHOLML" = betterproto.enum_field(5) + jnkhgfiljpb: bool = betterproto.bool_field(2) + retcode: int = betterproto.uint32_field(7) + + +@dataclass +class SellItemCsReq(betterproto.Message): + olfkackgofk: bool = betterproto.bool_field(6) + cost_data: "ItemCostData" = betterproto.message_field(10) + + +@dataclass +class SellItemScRsp(betterproto.Message): + return_item_list: "ItemList" = betterproto.message_field(8) + retcode: int = betterproto.uint32_field(14) + + +@dataclass +class RechargeSuccNotify(betterproto.Message): + channel_order_no: str = betterproto.string_field(9) + month_card_outdate_time: int = betterproto.uint64_field(11) + item_list: "ItemList" = betterproto.message_field(6) + product_id: str = betterproto.string_field(12) + + +@dataclass +class ExchangeHcoinCsReq(betterproto.Message): + num: int = betterproto.uint32_field(12) + + +@dataclass +class ExchangeHcoinScRsp(betterproto.Message): + num: int = betterproto.uint32_field(12) + retcode: int = betterproto.uint32_field(13) + + +@dataclass +class AddEquipmentScNotify(betterproto.Message): + mdmgkhlhiin: int = betterproto.uint32_field(1) + + +@dataclass +class GetRecyleTimeCsReq(betterproto.Message): + cjlndnilgmf: List[int] = betterproto.uint32_field(2) + + +@dataclass +class GetRecyleTimeScRsp(betterproto.Message): + fcokffeapmi: List["Material0"] = betterproto.message_field(1) + retcode: int = betterproto.uint32_field(7) + + +@dataclass +class FNHMMMKJGPB(betterproto.Message): + ojemelhcmpj: int = betterproto.uint32_field(1) + formula_id: int = betterproto.uint32_field(2) + + +@dataclass +class ComposeLimitNumCompleteNotify(betterproto.Message): + dchnaedinmm: List["FNHMMMKJGPB"] = betterproto.message_field(5) + + +@dataclass +class ComposeLimitNumUpdateNotify(betterproto.Message): + fglfgjdpjpd: "FNHMMMKJGPB" = betterproto.message_field(5) + + +@dataclass +class DestroyItemCsReq(betterproto.Message): + cur_item_count: int = betterproto.uint32_field(5) + item_count: int = betterproto.uint32_field(11) + item_id: int = betterproto.uint32_field(1) + + +@dataclass +class DestroyItemScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(5) + cur_item_count: int = betterproto.uint32_field(7) + + +@dataclass +class GetMarkItemListCsReq(betterproto.Message): + pass + + +@dataclass +class GetMarkItemListScRsp(betterproto.Message): + pdbihonolfj: List[int] = betterproto.uint32_field(12) + retcode: int = betterproto.uint32_field(10) + + +@dataclass +class MarkItemCsReq(betterproto.Message): + naehphhdgek: bool = betterproto.bool_field(2) + item_id: int = betterproto.uint32_field(13) + + +@dataclass +class MarkItemScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(7) + item_id: int = betterproto.uint32_field(3) + naehphhdgek: bool = betterproto.bool_field(12) + + +@dataclass +class CancelMarkItemNotify(betterproto.Message): + item_id: int = betterproto.uint32_field(10) + + +@dataclass +class SyncTurnFoodNotify(betterproto.Message): + fdbjlgdhcdo: List[int] = betterproto.uint32_field(3) + kmjefmfblli: List["TurnFoodSwitch"] = betterproto.enum_field(7) + + +@dataclass +class SetTurnFoodSwitchCsReq(betterproto.Message): + bndlhjhalmb: bool = betterproto.bool_field(4) + jcakhhkfdfn: "TurnFoodSwitch" = betterproto.enum_field(13) + + +@dataclass +class SetTurnFoodSwitchScRsp(betterproto.Message): + bndlhjhalmb: bool = betterproto.bool_field(4) + jcakhhkfdfn: "TurnFoodSwitch" = betterproto.enum_field(10) + retcode: int = betterproto.uint32_field(15) + + +@dataclass +class GeneralVirtualItemDataNotify(betterproto.Message): + pkbahpfjgdb: bool = betterproto.bool_field(4) + fdjkccgdnka: List["PileItem"] = betterproto.message_field(13) + + +@dataclass +class RelicFilterPlanIcon(betterproto.Message): + is_avatar_icon: bool = betterproto.bool_field(8) + icon_id: int = betterproto.uint32_field(10) + + +@dataclass +class RelicFilterPlan(betterproto.Message): + slot_index: int = betterproto.uint32_field(2) + update_timestamp: int = betterproto.int64_field(11) + avatar_id_on_create: int = betterproto.uint32_field(6) + is_marked: bool = betterproto.bool_field(8) + settings: "RelicFilterPlanSettings" = betterproto.message_field(13) + name: str = betterproto.string_field(1) + icon: "RelicFilterPlanIcon" = betterproto.message_field(3) + + +@dataclass +class GetRelicFilterPlanCsReq(betterproto.Message): + pass + + +@dataclass +class GetRelicFilterPlanScRsp(betterproto.Message): + relic_filter_plan_list: List["RelicFilterPlan"] = betterproto.message_field(12) + retcode: int = betterproto.uint32_field(3) + + +@dataclass +class AddRelicFilterPlanCsReq(betterproto.Message): + is_marked: bool = betterproto.bool_field(7) + name: str = betterproto.string_field(10) + icon: "RelicFilterPlanIcon" = betterproto.message_field(13) + settings: "RelicFilterPlanSettings" = betterproto.message_field(6) + avatar_id_on_create: int = betterproto.uint32_field(3) + + +@dataclass +class AddRelicFilterPlanScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(2) + plan: "RelicFilterPlan" = betterproto.message_field(14) + + +@dataclass +class ModifyRelicFilterPlanCsReq(betterproto.Message): + name: str = betterproto.string_field(9) + icon: "RelicFilterPlanIcon" = betterproto.message_field(15) + settings: "RelicFilterPlanSettings" = betterproto.message_field( + 8 + ) + slot_index: int = betterproto.uint32_field(10) + + +@dataclass +class ModifyRelicFilterPlanScRsp(betterproto.Message): + name: str = betterproto.string_field(1) + icon: "RelicFilterPlanIcon" = betterproto.message_field(2) + settings: "RelicFilterPlanSettings" = betterproto.message_field( + 14 + ) + retcode: int = betterproto.uint32_field(5) + slot_index: int = betterproto.uint32_field(4) + update_timestamp: int = betterproto.int64_field(11) + + +@dataclass +class DeleteRelicFilterPlanCsReq(betterproto.Message): + is_batch_op: bool = betterproto.bool_field(3) + slot_index_list: List[int] = betterproto.uint32_field(10) + + +@dataclass +class DeleteRelicFilterPlanScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(3) + ndobmajmlnk: List[int] = betterproto.uint32_field(1) + iemnpgomjco: bool = betterproto.bool_field(4) + + +@dataclass +class MarkRelicFilterPlanCsReq(betterproto.Message): + slot_index_list: List[int] = betterproto.uint32_field(14) + is_mark: bool = betterproto.bool_field(8) + is_batch_op: bool = betterproto.bool_field(5) + + +@dataclass +class MarkRelicFilterPlanScRsp(betterproto.Message): + slot_index_list: List[int] = betterproto.uint32_field(11) + retcode: int = betterproto.uint32_field(2) + is_batch_op: bool = betterproto.bool_field(1) + is_mark: bool = betterproto.bool_field(3) + + +@dataclass +class RelicFilterPlanClearNameScNotify(betterproto.Message): + max_times: int = betterproto.uint32_field(15) + + +@dataclass +class RelicReforgeCsReq(betterproto.Message): + relic_unique_id: int = betterproto.uint32_field(12) + + +@dataclass +class RelicReforgeScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(3) + + +@dataclass +class RelicReforgeConfirmCsReq(betterproto.Message): + relic_unique_id: int = betterproto.uint32_field(4) + is_cancel: bool = betterproto.bool_field(6) + + +@dataclass +class RelicReforgeConfirmScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(5) + + +@dataclass +class MusicData(betterproto.Message): + id: int = betterproto.uint32_field(12) + group_id: int = betterproto.uint32_field(9) + is_played: bool = betterproto.bool_field(1) + + +@dataclass +class GetJukeboxDataCsReq(betterproto.Message): + pass + + +@dataclass +class GetJukeboxDataScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(8) + current_music_id: int = betterproto.uint32_field(10) + unlocked_music_list: List["MusicData"] = betterproto.message_field(12) + + +@dataclass +class PlayBackGroundMusicCsReq(betterproto.Message): + play_music_id: int = betterproto.uint32_field(11) + + +@dataclass +class PlayBackGroundMusicScRsp(betterproto.Message): + play_music_id: int = betterproto.uint32_field(6) + retcode: int = betterproto.uint32_field(3) + current_music_id: int = betterproto.uint32_field(10) + + +@dataclass +class UnlockBackGroundMusicCsReq(betterproto.Message): + unlock_ids: List[int] = betterproto.uint32_field(4) + + +@dataclass +class UnlockBackGroundMusicScRsp(betterproto.Message): + unlocked_music_list: List["MusicData"] = betterproto.message_field(15) + oghdilhdleb: List[int] = betterproto.uint32_field(5) + retcode: int = betterproto.uint32_field(9) + + +@dataclass +class TrialBackGroundMusicCsReq(betterproto.Message): + pigbbgclamj: int = betterproto.uint32_field(13) + + +@dataclass +class TrialBackGroundMusicScRsp(betterproto.Message): + pigbbgclamj: int = betterproto.uint32_field(5) + retcode: int = betterproto.uint32_field(12) + + +@dataclass +class GetStageLineupCsReq(betterproto.Message): + pass + + +@dataclass +class JLCHBKKFANL(betterproto.Message): + stage_type: int = betterproto.uint32_field(8) + dogdacflboe: int = betterproto.uint32_field(10) + + +@dataclass +class GetStageLineupScRsp(betterproto.Message): + nmkpekmmnbp: List["JLCHBKKFANL"] = betterproto.message_field(2) + retcode: int = betterproto.uint32_field(3) + + +@dataclass +class LineupAvatar(betterproto.Message): + avatar_type: "AvatarType" = betterproto.enum_field(3) + hp: int = betterproto.uint32_field(12) + id: int = betterproto.uint32_field(15) + slot: int = betterproto.uint32_field(7) + satiety: int = betterproto.uint32_field(5) + sp_bar: "SpBarInfo" = betterproto.message_field(10) + + +@dataclass +class LineupInfo(betterproto.Message): + story_line_avatar_id_list: List[int] = betterproto.uint32_field(10) + name: str = betterproto.string_field(14) + mp: int = betterproto.uint32_field(7) + mankkfpbfcb: List[int] = betterproto.uint32_field(1) + kompcjpapkm: List[int] = betterproto.uint32_field(15) + is_virtual: bool = betterproto.bool_field(12) + avatar_list: List["LineupAvatar"] = betterproto.message_field(5) + plane_id: int = betterproto.uint32_field(11) + extra_lineup_type: "ExtraLineupType" = betterproto.enum_field(13) + leader_slot: int = betterproto.uint32_field(6) + max_mp: int = betterproto.uint32_field(2) + bfnbklmamkb: bool = betterproto.bool_field(4) + game_story_line_id: int = betterproto.uint32_field(8) + index: int = betterproto.uint32_field(9) + + +@dataclass +class GetCurLineupDataCsReq(betterproto.Message): + pass + + +@dataclass +class GetCurLineupDataScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(13) + lineup: "LineupInfo" = betterproto.message_field(4) + + +@dataclass +class JoinLineupCsReq(betterproto.Message): + base_avatar_id: int = betterproto.uint32_field(2) + is_virtual: bool = betterproto.bool_field(3) + avatar_type: "AvatarType" = betterproto.enum_field(10) + slot: int = betterproto.uint32_field(14) + extra_lineup_type: "ExtraLineupType" = betterproto.enum_field(7) + index: int = betterproto.uint32_field(4) + plane_id: int = betterproto.uint32_field(6) + + +@dataclass +class JoinLineupScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(14) + + +@dataclass +class QuitLineupCsReq(betterproto.Message): + plane_id: int = betterproto.uint32_field(11) + index: int = betterproto.uint32_field(15) + extra_lineup_type: "ExtraLineupType" = betterproto.enum_field(9) + base_avatar_id: int = betterproto.uint32_field(2) + avatar_type: "AvatarType" = betterproto.enum_field(3) + is_virtual: bool = betterproto.bool_field(6) + + +@dataclass +class QuitLineupScRsp(betterproto.Message): + is_virtual: bool = betterproto.bool_field(3) + hiofpdkdofd: bool = betterproto.bool_field(5) + plane_id: int = betterproto.uint32_field(6) + base_avatar_id: int = betterproto.uint32_field(9) + retcode: int = betterproto.uint32_field(7) + + +@dataclass +class SwapLineupCsReq(betterproto.Message): + extra_lineup_type: "ExtraLineupType" = betterproto.enum_field(7) + plane_id: int = betterproto.uint32_field(11) + nedikhngmbh: int = betterproto.uint32_field(5) + ellidanjnob: int = betterproto.uint32_field(4) + index: int = betterproto.uint32_field(1) + is_virtual: bool = betterproto.bool_field(9) + + +@dataclass +class SwapLineupScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(3) + + +@dataclass +class SyncLineupNotify(betterproto.Message): + reason_list: List["SyncLineupReason"] = betterproto.enum_field(12) + lineup: "LineupInfo" = betterproto.message_field(10) + + +@dataclass +class GetLineupAvatarDataCsReq(betterproto.Message): + pass + + +@dataclass +class LineupAvatarData(betterproto.Message): + id: int = betterproto.uint32_field(13) + avatar_type: "AvatarType" = betterproto.enum_field(11) + hp: int = betterproto.uint32_field(6) + + +@dataclass +class GetLineupAvatarDataScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(1) + avatar_data_list: List["LineupAvatarData"] = betterproto.message_field(10) + + +@dataclass +class ChangeLineupLeaderCsReq(betterproto.Message): + slot: int = betterproto.uint32_field(5) + + +@dataclass +class ChangeLineupLeaderScRsp(betterproto.Message): + slot: int = betterproto.uint32_field(8) + retcode: int = betterproto.uint32_field(4) + + +@dataclass +class SwitchLineupIndexCsReq(betterproto.Message): + index: int = betterproto.uint32_field(10) + + +@dataclass +class SwitchLineupIndexScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(13) + index: int = betterproto.uint32_field(4) + + +@dataclass +class SetLineupNameCsReq(betterproto.Message): + name: str = betterproto.string_field(14) + index: int = betterproto.uint32_field(12) + + +@dataclass +class SetLineupNameScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(10) + index: int = betterproto.uint32_field(13) + name: str = betterproto.string_field(12) + + +@dataclass +class GetAllLineupDataCsReq(betterproto.Message): + pass + + +@dataclass +class GetAllLineupDataScRsp(betterproto.Message): + lineup_list: List["LineupInfo"] = betterproto.message_field(15) + retcode: int = betterproto.uint32_field(3) + cur_index: int = betterproto.uint32_field(7) + + +@dataclass +class VirtualLineupDestroyNotify(betterproto.Message): + plane_id: int = betterproto.uint32_field(14) + + +@dataclass +class LineupSlotData(betterproto.Message): + id: int = betterproto.uint32_field(15) + avatar_type: "AvatarType" = betterproto.enum_field(11) + slot: int = betterproto.uint32_field(3) + + +@dataclass +class ReplaceLineupCsReq(betterproto.Message): + plane_id: int = betterproto.uint32_field(1) + extra_lineup_type: "ExtraLineupType" = betterproto.enum_field(14) + is_virtual: bool = betterproto.bool_field(13) + index: int = betterproto.uint32_field(4) + game_story_line_id: int = betterproto.uint32_field(10) + leader_slot: int = betterproto.uint32_field(6) + lineup_slot_list: List["LineupSlotData"] = betterproto.message_field(12) + + +@dataclass +class ReplaceLineupScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(8) + + +@dataclass +class ExtraLineupDestroyNotify(betterproto.Message): + extra_lineup_type: "ExtraLineupType" = betterproto.enum_field(1) + + +@dataclass +class VirtualLineupTrialAvatarChangeScNotify(betterproto.Message): + plane_id: int = betterproto.uint32_field(7) + iblbnianphd: List[int] = betterproto.uint32_field(5) + kfmffggjmne: List[int] = betterproto.uint32_field(2) + cliigmnmhna: bool = betterproto.bool_field(14) + + +@dataclass +class LobbyCreateCsReq(betterproto.Message): + ejofcnaedhk: "EPEGHCGCMHP" = betterproto.message_field(11) + nbdlpgbidlc: "FightGameMode" = betterproto.enum_field(9) + nepoddojjfe: int = betterproto.uint32_field(4) + + +@dataclass +class LobbyCreateScRsp(betterproto.Message): + nepoddojjfe: int = betterproto.uint32_field(8) + lipjdjpmokb: List["CBBDIOMIFHD"] = betterproto.message_field(11) + room_id: int = betterproto.uint64_field(13) + nbdlpgbidlc: "FightGameMode" = betterproto.enum_field(2) + retcode: int = betterproto.uint32_field(15) + + +@dataclass +class LobbyInviteCsReq(betterproto.Message): + uid_list: List[int] = betterproto.uint32_field(12) + + +@dataclass +class LobbyInviteScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(3) + uid_list: List[int] = betterproto.uint32_field(13) + + +@dataclass +class LobbyJoinCsReq(betterproto.Message): + room_id: int = betterproto.uint64_field(12) + ejofcnaedhk: "EPEGHCGCMHP" = betterproto.message_field(5) + + +@dataclass +class LobbyJoinScRsp(betterproto.Message): + nepoddojjfe: int = betterproto.uint32_field(9) + lipjdjpmokb: List["CBBDIOMIFHD"] = betterproto.message_field(6) + room_id: int = betterproto.uint64_field(7) + nbdlpgbidlc: "FightGameMode" = betterproto.enum_field(13) + retcode: int = betterproto.uint32_field(8) + + +@dataclass +class LobbyQuitCsReq(betterproto.Message): + pass + + +@dataclass +class LobbyQuitScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(12) + + +@dataclass +class LobbyStartFightCsReq(betterproto.Message): + pass + + +@dataclass +class LobbyStartFightScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(13) + + +@dataclass +class LobbyModifyPlayerInfoCsReq(betterproto.Message): + hfdjaelbnga: int = betterproto.uint32_field(6) + ejofcnaedhk: "EPEGHCGCMHP" = betterproto.message_field(5) + type: "LobbyModifyType" = betterproto.enum_field(3) + + +@dataclass +class LobbyModifyPlayerInfoScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(2) + + +@dataclass +class LobbySyncInfoScNotify(betterproto.Message): + uid: int = betterproto.uint32_field(5) + type: "LobbyModifyType" = betterproto.enum_field(9) + lipjdjpmokb: List["CBBDIOMIFHD"] = betterproto.message_field(14) + + +@dataclass +class LobbyKickOutCsReq(betterproto.Message): + uid: int = betterproto.uint32_field(4) + + +@dataclass +class LobbyKickOutScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(2) + + +@dataclass +class LobbyInviteScNotify(betterproto.Message): + room_id: int = betterproto.uint32_field(10) + nbdlpgbidlc: "FightGameMode" = betterproto.enum_field(13) + sender_id: int = betterproto.uint32_field(9) + + +@dataclass +class LobbyGetInfoCsReq(betterproto.Message): + pass + + +@dataclass +class LobbyGetInfoScRsp(betterproto.Message): + nepoddojjfe: int = betterproto.uint32_field(8) + nogfeemnhpc: int = betterproto.uint64_field(6) + room_id: int = betterproto.uint64_field(7) + lipjdjpmokb: List["CBBDIOMIFHD"] = betterproto.message_field(13) + nbdlpgbidlc: "FightGameMode" = betterproto.enum_field(5) + retcode: int = betterproto.uint32_field(3) + + +@dataclass +class LobbyInteractCsReq(betterproto.Message): + ihcilnhklmc: "IMAONMHILNE" = betterproto.enum_field(2) + cbegnbkmhcd: int = betterproto.uint32_field(10) + + +@dataclass +class LobbyInteractScRsp(betterproto.Message): + cbegnbkmhcd: int = betterproto.uint32_field(10) + retcode: int = betterproto.uint32_field(11) + + +@dataclass +class LobbyInteractScNotify(betterproto.Message): + ihcilnhklmc: "IMAONMHILNE" = betterproto.enum_field(7) + sender_id: int = betterproto.uint32_field(5) + + +@dataclass +class GetMailCsReq(betterproto.Message): + cijefnoojjk: int = betterproto.uint32_field(4) + dapcdnelcma: int = betterproto.uint32_field(3) + + +@dataclass +class ClientMail(betterproto.Message): + is_read: bool = betterproto.bool_field(12) + time: int = betterproto.int64_field(6) + attachment: "ItemList" = betterproto.message_field(13) + template_id: int = betterproto.uint32_field(9) + para_list: List[str] = betterproto.string_field(14) + mail_type: "MailType" = betterproto.enum_field(8) + expire_time: int = betterproto.int64_field(1) + id: int = betterproto.uint32_field(10) + sender: str = betterproto.string_field(5) + title: str = betterproto.string_field(2) + content: str = betterproto.string_field(4) + + +@dataclass +class GetMailScRsp(betterproto.Message): + mail_list: List["ClientMail"] = betterproto.message_field(12) + retcode: int = betterproto.uint32_field(7) + start: int = betterproto.uint32_field(14) + total_num: int = betterproto.uint32_field(13) + notice_mail_list: List["ClientMail"] = betterproto.message_field(3) + is_end: bool = betterproto.bool_field(8) + + +@dataclass +class MarkReadMailCsReq(betterproto.Message): + id: int = betterproto.uint32_field(8) + + +@dataclass +class MarkReadMailScRsp(betterproto.Message): + id: int = betterproto.uint32_field(8) + retcode: int = betterproto.uint32_field(4) + + +@dataclass +class DelMailCsReq(betterproto.Message): + id_list: List[int] = betterproto.uint32_field(1) + + +@dataclass +class DelMailScRsp(betterproto.Message): + id_list: List[int] = betterproto.uint32_field(4) + retcode: int = betterproto.uint32_field(15) + + +@dataclass +class TakeMailAttachmentCsReq(betterproto.Message): + mail_id_list: List[int] = betterproto.uint32_field(7) + optional_reward_id: int = betterproto.uint32_field(1) + + +@dataclass +class ClientMailAttachmentItem(betterproto.Message): + item_id: int = betterproto.uint32_field(3) + mail_id: int = betterproto.uint32_field(4) + + +@dataclass +class TakeMailAttachmentScRsp(betterproto.Message): + succ_mail_id_list: List[int] = betterproto.uint32_field(15) + attachment: "ItemList" = betterproto.message_field(12) + fail_mail_list: List["ClientMailAttachmentItem"] = betterproto.message_field(7) + retcode: int = betterproto.uint32_field(6) + + +@dataclass +class NewMailScNotify(betterproto.Message): + mail_id_list: List[int] = betterproto.uint32_field(6) + + +@dataclass +class RogueMapRotateInfo(betterproto.Message): + rogue_map: "RotateMapInfo" = betterproto.message_field(6) + nflbondjaie: int = betterproto.uint32_field(15) + era_flipper_region_id: int = betterproto.int32_field(4) + rotater_data_list: List["RotaterData"] = betterproto.message_field(7) + is_rotate: bool = betterproto.bool_field(13) + energy_info: "RotaterEnergyInfo" = betterproto.message_field(8) + charger_info: List["ChargerInfo"] = betterproto.message_field(11) + + +@dataclass +class RotaterEnergyInfo(betterproto.Message): + cur_num: int = betterproto.uint32_field(15) + max_num: int = betterproto.uint32_field(14) + + +@dataclass +class RotateMapInfo(betterproto.Message): + rotate_vector: "Vector4" = betterproto.message_field(4) + vector: "Vector" = betterproto.message_field(10) + + +@dataclass +class EnterMapRotationRegionCsReq(betterproto.Message): + motion: "MotionInfo" = betterproto.message_field(7) + era_flipper_region_id: int = betterproto.uint32_field(13) + nflbondjaie: int = betterproto.uint32_field(6) + + +@dataclass +class EnterMapRotationRegionScRsp(betterproto.Message): + energy_info: "RotaterEnergyInfo" = betterproto.message_field(10) + nflbondjaie: int = betterproto.uint32_field(7) + motion: "MotionInfo" = betterproto.message_field(2) + retcode: int = betterproto.uint32_field(3) + client_pos_version: int = betterproto.uint32_field(12) + era_flipper_region_id: int = betterproto.uint32_field(15) + + +@dataclass +class ChargerInfo(betterproto.Message): + group_id: int = betterproto.uint32_field(2) + glhagjgaehe: int = betterproto.uint32_field(15) + + +@dataclass +class InteractChargerCsReq(betterproto.Message): + charger_info: "ChargerInfo" = betterproto.message_field(7) + + +@dataclass +class InteractChargerScRsp(betterproto.Message): + charger_info: "ChargerInfo" = betterproto.message_field(12) + energy_info: "RotaterEnergyInfo" = betterproto.message_field(8) + retcode: int = betterproto.uint32_field(4) + + +@dataclass +class RotaterData(betterproto.Message): + glhagjgaehe: int = betterproto.uint32_field(5) + group_id: int = betterproto.uint32_field(8) + lkefolcgfgd: float = betterproto.float_field(15) + + +@dataclass +class DeployRotaterCsReq(betterproto.Message): + rotater_data: "RotaterData" = betterproto.message_field(4) + + +@dataclass +class DeployRotaterScRsp(betterproto.Message): + energy_info: "RotaterEnergyInfo" = betterproto.message_field(15) + rotater_data: "RotaterData" = betterproto.message_field(7) + retcode: int = betterproto.uint32_field(9) + + +@dataclass +class RotateMapCsReq(betterproto.Message): + group_id: int = betterproto.uint32_field(14) + rogue_map: "RotateMapInfo" = betterproto.message_field(6) + motion: "MotionInfo" = betterproto.message_field(3) + glhagjgaehe: int = betterproto.uint32_field(12) + + +@dataclass +class RotateMapScRsp(betterproto.Message): + motion: "MotionInfo" = betterproto.message_field(11) + client_pos_version: int = betterproto.uint32_field(2) + retcode: int = betterproto.uint32_field(8) + + +@dataclass +class LeaveMapRotationRegionCsReq(betterproto.Message): + motion: "MotionInfo" = betterproto.message_field(11) + + +@dataclass +class LeaveMapRotationRegionScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(3) + client_pos_version: int = betterproto.uint32_field(1) + motion: "MotionInfo" = betterproto.message_field(10) + + +@dataclass +class GetMapRotationDataCsReq(betterproto.Message): + pass + + +@dataclass +class GetMapRotationDataScRsp(betterproto.Message): + rogue_map: "RotateMapInfo" = betterproto.message_field(7) + nflbondjaie: int = betterproto.uint32_field(6) + charger_info: List["ChargerInfo"] = betterproto.message_field(13) + era_flipper_region_id: int = betterproto.int32_field(2) + energy_info: "RotaterEnergyInfo" = betterproto.message_field(15) + retcode: int = betterproto.uint32_field(3) + omejllmnpcn: bool = betterproto.bool_field(10) + rotater_data_list: List["RotaterData"] = betterproto.message_field(11) + + +@dataclass +class ResetMapRotationRegionCsReq(betterproto.Message): + rogue_map: "RotateMapInfo" = betterproto.message_field(9) + motion: "MotionInfo" = betterproto.message_field(8) + + +@dataclass +class ResetMapRotationRegionScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(12) + motion: "MotionInfo" = betterproto.message_field(8) + client_pos_version: int = betterproto.uint32_field(4) + + +@dataclass +class LeaveMapRotationRegionScNotify(betterproto.Message): + pass + + +@dataclass +class UpdateEnergyScNotify(betterproto.Message): + energy_info: "RotaterEnergyInfo" = betterproto.message_field(12) + + +@dataclass +class UpdateMapRotationDataScNotify(betterproto.Message): + rogue_map: "RotateMapInfo" = betterproto.message_field(4) + nflbondjaie: int = betterproto.uint32_field(2) + charger_info: List["ChargerInfo"] = betterproto.message_field(13) + energy_info: "RotaterEnergyInfo" = betterproto.message_field(14) + rotater_data_list: List["RotaterData"] = betterproto.message_field(6) + omejllmnpcn: bool = betterproto.bool_field(15) + era_flipper_region_id: int = betterproto.int32_field(5) + + +@dataclass +class RemoveRotaterCsReq(betterproto.Message): + rotater_data: "RotaterData" = betterproto.message_field(5) + + +@dataclass +class RemoveRotaterScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(10) + energy_info: "RotaterEnergyInfo" = betterproto.message_field(7) + rotater_data: "RotaterData" = betterproto.message_field(9) + + +@dataclass +class UpdateRotaterScNotify(betterproto.Message): + rotater_data_list: List["RotaterData"] = betterproto.message_field(8) + + +@dataclass +class MarbleGetDataCsReq(betterproto.Message): + pass + + +@dataclass +class MarbleGetDataScRsp(betterproto.Message): + iogdkgfdfpc: List[int] = betterproto.uint32_field(9) + ojnpgiljien: List[int] = betterproto.uint32_field(7) + retcode: int = betterproto.uint32_field(3) + mpbmpffgibo: List[int] = betterproto.uint32_field(4) + score_id: int = betterproto.int32_field(15) + + +@dataclass +class MarbleLevelFinishCsReq(betterproto.Message): + nlibkabfgcc: int = betterproto.uint32_field(1) + pmkangdflki: List[int] = betterproto.uint32_field(14) + + +@dataclass +class MarbleLevelFinishScRsp(betterproto.Message): + nlibkabfgcc: int = betterproto.uint32_field(7) + retcode: int = betterproto.uint32_field(1) + + +@dataclass +class MarbleShopBuyCsReq(betterproto.Message): + pmkangdflki: List[int] = betterproto.uint32_field(11) + + +@dataclass +class MarbleShopBuyScRsp(betterproto.Message): + pmkangdflki: List[int] = betterproto.uint32_field(11) + retcode: int = betterproto.uint32_field(4) + + +@dataclass +class MarbleUnlockSealScNotify(betterproto.Message): + pmkangdflki: List[int] = betterproto.uint32_field(5) + + +@dataclass +class MarblePvpDataUpdateScNotify(betterproto.Message): + score_id: int = betterproto.int32_field(4) + + +@dataclass +class MarbleUpdateShownSealCsReq(betterproto.Message): + ehenkplcpch: List[int] = betterproto.uint32_field(6) + + +@dataclass +class MarbleUpdateShownSealScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(6) + ehenkplcpch: List[int] = betterproto.uint32_field(9) + + +@dataclass +class MarkChestInfo(betterproto.Message): + plane_id: int = betterproto.uint32_field(3) + config_id: int = betterproto.uint32_field(4) + group_id: int = betterproto.uint32_field(5) + floor_id: int = betterproto.uint32_field(15) + + +@dataclass +class MarkChestFuncInfo(betterproto.Message): + func_id: int = betterproto.uint32_field(6) + mark_chest_info_list: List["MarkChestInfo"] = betterproto.message_field(15) + mark_time: int = betterproto.int64_field(12) + + +@dataclass +class GetMarkChestCsReq(betterproto.Message): + pass + + +@dataclass +class GetMarkChestScRsp(betterproto.Message): + mark_chest_func_info: List["MarkChestFuncInfo"] = betterproto.message_field(13) + retcode: int = betterproto.uint32_field(2) + + +@dataclass +class UpdateMarkChestCsReq(betterproto.Message): + mark_chest_info_list: List["MarkChestInfo"] = betterproto.message_field(9) + trigger_param_id: int = betterproto.uint32_field(6) + func_id: int = betterproto.uint32_field(3) + + +@dataclass +class UpdateMarkChestScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(14) + trigger_param_id: int = betterproto.uint32_field(2) + mark_chest_func_info: List["MarkChestFuncInfo"] = betterproto.message_field(15) + func_id: int = betterproto.uint32_field(4) + + +@dataclass +class MarkChestChangedScNotify(betterproto.Message): + mark_chest_func_info: List["MarkChestFuncInfo"] = betterproto.message_field(11) + + +@dataclass +class StartMatchCsReq(betterproto.Message): + nbdlpgbidlc: "FightGameMode" = betterproto.enum_field(2) + ejofcnaedhk: "EPEGHCGCMHP" = betterproto.message_field(6) + + +@dataclass +class StartMatchScRsp(betterproto.Message): + ejofcnaedhk: "EPEGHCGCMHP" = betterproto.message_field(3) + retcode: int = betterproto.uint32_field(5) + + +@dataclass +class CancelMatchCsReq(betterproto.Message): + pass + + +@dataclass +class CancelMatchScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(4) + + +@dataclass +class MatchResultScNotify(betterproto.Message): + retcode: int = betterproto.uint32_field(4) + lipjdjpmokb: List["CBBDIOMIFHD"] = betterproto.message_field(6) + + +@dataclass +class GetCrossInfoCsReq(betterproto.Message): + pass + + +@dataclass +class GetCrossInfoScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(13) + room_id: int = betterproto.uint64_field(3) + nbdlpgbidlc: "FightGameMode" = betterproto.enum_field(8) + nogfeemnhpc: int = betterproto.uint64_field(1) + + +@dataclass +class MatchThreeGetDataCsReq(betterproto.Message): + pass + + +@dataclass +class LMPIECFMFOI(betterproto.Message): + ebgmbdmpegm: int = betterproto.uint32_field(4) + level_id: int = betterproto.uint32_field(10) + + +@dataclass +class DHONNIHMACI(betterproto.Message): + pos: int = betterproto.uint32_field(12) + count: int = betterproto.uint32_field(4) + bkmpfeocfib: int = betterproto.uint32_field(13) + fmkkabmdinj: int = betterproto.uint32_field(7) + + +@dataclass +class ABGEJNBCDJK(betterproto.Message): + ilbhdlmlmck: Dict[int, int] = betterproto.map_field( + 15, betterproto.TYPE_UINT32, betterproto.TYPE_UINT32 + ) + bgafcobnlpm: List["DHONNIHMACI"] = betterproto.message_field(13) + jmbciclchkd: List["LMPIECFMFOI"] = betterproto.message_field(14) + begmfiaphlm: Dict[int, int] = betterproto.map_field( + 1, betterproto.TYPE_UINT32, betterproto.TYPE_UINT32 + ) + + +@dataclass +class MatchThreeGetDataScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(7) + mfkjdoeblim: "ABGEJNBCDJK" = betterproto.message_field(5) + + +@dataclass +class MatchThreeLevelEndCsReq(betterproto.Message): + uuid: str = betterproto.string_field(15) + bkmpfeocfib: int = betterproto.uint32_field(7) + ilbhdlmlmck: Dict[int, int] = betterproto.map_field( + 9, betterproto.TYPE_UINT32, betterproto.TYPE_UINT32 + ) + fmkkabmdinj: int = betterproto.uint32_field(12) + jeppfdinbnb: List[int] = betterproto.uint32_field(2) + ebgmbdmpegm: int = betterproto.uint32_field(3) + level_id: int = betterproto.uint32_field(14) + + +@dataclass +class MatchThreeLevelEndScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(5) + ebgmbdmpegm: int = betterproto.uint32_field(2) + level_id: int = betterproto.uint32_field(7) + + +@dataclass +class MatchThreeSyncDataScNotify(betterproto.Message): + mfkjdoeblim: "ABGEJNBCDJK" = betterproto.message_field(1) + + +@dataclass +class MatchThreeSetBirdPosCsReq(betterproto.Message): + bkmpfeocfib: int = betterproto.uint32_field(1) + pos: int = betterproto.uint32_field(8) + + +@dataclass +class MatchThreeSetBirdPosScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(12) + pos: int = betterproto.uint32_field(5) + bkmpfeocfib: int = betterproto.uint32_field(8) + + +@dataclass +class GetNpcMessageGroupCsReq(betterproto.Message): + contact_id_list: List[int] = betterproto.uint32_field(3) + + +@dataclass +class MessageItem(betterproto.Message): + text_id: int = betterproto.uint32_field(13) + item_id: int = betterproto.uint32_field(15) + + +@dataclass +class MessageSection(betterproto.Message): + item_list: List["MessageItem"] = betterproto.message_field(5) + id: int = betterproto.uint32_field(14) + status: "MessageSectionStatus" = betterproto.enum_field(9) + frozen_item_id: int = betterproto.uint32_field(8) + message_item_list: List[int] = betterproto.uint32_field(12) + + +@dataclass +class MessageGroup(betterproto.Message): + message_section_id: int = betterproto.uint32_field(7) + refresh_time: int = betterproto.int64_field(6) + message_section_list: List["MessageSection"] = betterproto.message_field(8) + status: "MessageGroupStatus" = betterproto.enum_field(14) + id: int = betterproto.uint32_field(10) + + +@dataclass +class GetNpcMessageGroupScRsp(betterproto.Message): + message_group_list: List["MessageGroup"] = betterproto.message_field(2) + retcode: int = betterproto.uint32_field(3) + + +@dataclass +class GetNpcStatusCsReq(betterproto.Message): + pass + + +@dataclass +class NpcStatus(betterproto.Message): + is_finish: bool = betterproto.bool_field(11) + npc_id: int = betterproto.uint32_field(15) + + +@dataclass +class GroupStatus(betterproto.Message): + group_id: int = betterproto.uint32_field(15) + refresh_time: int = betterproto.int64_field(13) + group_status: "MessageGroupStatus" = betterproto.enum_field(1) + + +@dataclass +class SectionStatus(betterproto.Message): + section_status: "MessageSectionStatus" = betterproto.enum_field(1) + section_id: int = betterproto.uint32_field(5) + + +@dataclass +class GetNpcStatusScRsp(betterproto.Message): + npc_status_list: List["NpcStatus"] = betterproto.message_field(3) + retcode: int = betterproto.uint32_field(14) + + +@dataclass +class FinishItemIdCsReq(betterproto.Message): + text_id: int = betterproto.uint32_field(3) + item_id: int = betterproto.uint32_field(11) + + +@dataclass +class FinishItemIdScRsp(betterproto.Message): + item_id: int = betterproto.uint32_field(11) + text_id: int = betterproto.uint32_field(12) + retcode: int = betterproto.uint32_field(1) + + +@dataclass +class FinishSectionIdCsReq(betterproto.Message): + section_id: int = betterproto.uint32_field(1) + + +@dataclass +class FinishSectionIdScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(9) + section_id: int = betterproto.uint32_field(6) + reward: "ItemList" = betterproto.message_field(12) + + +@dataclass +class FinishPerformSectionIdCsReq(betterproto.Message): + item_list: List["MessageItem"] = betterproto.message_field(6) + section_id: int = betterproto.uint32_field(10) + + +@dataclass +class FinishPerformSectionIdScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(1) + item_list: List["MessageItem"] = betterproto.message_field(14) + reward: "ItemList" = betterproto.message_field(4) + section_id: int = betterproto.uint32_field(10) + + +@dataclass +class GetMissionMessageInfoCsReq(betterproto.Message): + pass + + +@dataclass +class GetMissionMessageInfoScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(4) + apoldlgpkop: Dict[int, int] = betterproto.map_field( + 3, betterproto.TYPE_UINT32, betterproto.TYPE_UINT32 + ) + + +@dataclass +class ShareCsReq(betterproto.Message): + enfkggnomeo: int = betterproto.uint32_field(11) + + +@dataclass +class ADGNKECPOMA(betterproto.Message): + cccdkgamdlb: int = betterproto.uint32_field(9) + enfkggnomeo: int = betterproto.uint32_field(13) + + +@dataclass +class ShareScRsp(betterproto.Message): + reward: "ItemList" = betterproto.message_field(5) + retcode: int = betterproto.uint32_field(15) + fgplilebkgl: "ADGNKECPOMA" = betterproto.message_field(8) + + +@dataclass +class GetShareDataCsReq(betterproto.Message): + pass + + +@dataclass +class GetShareDataScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(4) + mfkjjbpndam: List["ADGNKECPOMA"] = betterproto.message_field(1) + + +@dataclass +class TakePictureCsReq(betterproto.Message): + pass + + +@dataclass +class TakePictureScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(1) + + +@dataclass +class NLBMCGCAEIO(betterproto.Message): + pildefkpkle: List[int] = betterproto.uint32_field(15) + type: int = betterproto.uint32_field(14) + afleajihneb: int = betterproto.uint32_field(12) + + +@dataclass +class TriggerVoiceCsReq(betterproto.Message): + mnelhnhckpj: List["NLBMCGCAEIO"] = betterproto.message_field(10) + + +@dataclass +class TriggerVoiceScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(6) + + +@dataclass +class CancelCacheNotifyCsReq(betterproto.Message): + type: "CancelCacheType" = betterproto.enum_field(1) + daily_index: List[int] = betterproto.uint32_field(2) + kcljmcakojf: List[str] = betterproto.string_field(15) + + +@dataclass +class CancelCacheNotifyScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(8) + + +@dataclass +class SecurityReportCsReq(betterproto.Message): + dgdlniefcpf: str = betterproto.string_field(10) + + +@dataclass +class SecurityReportScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(8) + + +@dataclass +class GMAAJHDFACD(betterproto.Message): + type: "MovieRacingType" = betterproto.enum_field(7) + level: int = betterproto.uint32_field(13) + pdomacfemgg: int = betterproto.uint32_field(9) + ifaikoioidd: int = betterproto.uint32_field(6) + + +@dataclass +class GetMovieRacingDataCsReq(betterproto.Message): + pass + + +@dataclass +class GetMovieRacingDataScRsp(betterproto.Message): + odjigebehgc: List["GMAAJHDFACD"] = betterproto.message_field(9) + retcode: int = betterproto.uint32_field(2) + + +@dataclass +class UpdateMovieRacingDataCsReq(betterproto.Message): + kihchdffpol: "GMAAJHDFACD" = betterproto.message_field(4) + + +@dataclass +class UpdateMovieRacingDataScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(4) + kihchdffpol: "GMAAJHDFACD" = betterproto.message_field(14) + + +@dataclass +class SubmitOrigamiItemCsReq(betterproto.Message): + lcbofmopgke: int = betterproto.uint32_field(9) + + +@dataclass +class SubmitOrigamiItemScRsp(betterproto.Message): + lcbofmopgke: int = betterproto.uint32_field(5) + retcode: int = betterproto.uint32_field(12) + + +@dataclass +class LCDKBMMEBFF(betterproto.Message): + content_id: int = betterproto.uint32_field(15) + floor_id_list: List[int] = betterproto.uint32_field(11) + entry_story_line_id: int = betterproto.uint32_field(6) + + +@dataclass +class LAMMCHABAGH(betterproto.Message): + state: int = betterproto.uint32_field(2) + group_id: int = betterproto.uint32_field(11) + config_id: int = betterproto.uint32_field(12) + + +@dataclass +class FCHOLNDIPKC(betterproto.Message): + floor_id: int = betterproto.uint32_field(14) + cljjafgfkel: List["LAMMCHABAGH"] = betterproto.message_field(5) + + +@dataclass +class GJLDMCNJOMC(betterproto.Message): + content_id: int = betterproto.uint32_field(4) + retcode: int = betterproto.uint32_field(2) + entry_story_line_id: int = betterproto.uint32_field(13) + lmebhnldkdj: List["FCHOLNDIPKC"] = betterproto.message_field(5) + + +@dataclass +class KLBHFHJDBFI(betterproto.Message): + ncnaonifpfm: bool = betterproto.bool_field(8) + bmcjhonbhjh: int = betterproto.uint32_field(6) + ifaikoioidd: int = betterproto.uint32_field(13) + level: int = betterproto.uint32_field(10) + + +@dataclass +class GetGunPlayDataCsReq(betterproto.Message): + pass + + +@dataclass +class GetGunPlayDataScRsp(betterproto.Message): + lnbfdjmnacn: List["KLBHFHJDBFI"] = betterproto.message_field(13) + retcode: int = betterproto.uint32_field(4) + + +@dataclass +class UpdateGunPlayDataCsReq(betterproto.Message): + pneifbegmdh: int = betterproto.uint32_field(1) + group_id: int = betterproto.uint32_field(8) + uuid: int = betterproto.uint64_field(3) + odfhnchiejn: "KLBHFHJDBFI" = betterproto.message_field(5) + + +@dataclass +class UpdateGunPlayDataScRsp(betterproto.Message): + odfhnchiejn: "KLBHFHJDBFI" = betterproto.message_field(1) + retcode: int = betterproto.uint32_field(8) + + +@dataclass +class JCDNMBCKPLF(betterproto.Message): + id: int = betterproto.uint32_field(10) + kcmjkgadpip: "DifficultyAdjustmentType" = betterproto.enum_field(1) + modifier_source_type: "GIILENMKCAH" = betterproto.enum_field(7) + + +@dataclass +class DifficultyAdjustmentGetDataCsReq(betterproto.Message): + pass + + +@dataclass +class DifficultyAdjustmentGetDataScRsp(betterproto.Message): + content_package_list: List["JCDNMBCKPLF"] = betterproto.message_field(1) + retcode: int = betterproto.uint32_field(7) + + +@dataclass +class DifficultyAdjustmentUpdateDataCsReq(betterproto.Message): + data: "JCDNMBCKPLF" = betterproto.message_field(7) + + +@dataclass +class DifficultyAdjustmentUpdateDataScRsp(betterproto.Message): + data: "JCDNMBCKPLF" = betterproto.message_field(4) + content_package_list: List["JCDNMBCKPLF"] = betterproto.message_field(15) + retcode: int = betterproto.uint32_field(5) + + +@dataclass +class MazeKillDirectCsReq(betterproto.Message): + modifier_source_type: "MNIJHMEPGNN" = betterproto.enum_field(7) + entity_list: List[int] = betterproto.uint32_field(1) + mmkogoknpkl: int = betterproto.uint32_field(5) + + +@dataclass +class MazeKillDirectScRsp(betterproto.Message): + entity_list: List[int] = betterproto.uint32_field(2) + retcode: int = betterproto.uint32_field(13) + + +@dataclass +class GetMissionDataCsReq(betterproto.Message): + pass + + +@dataclass +class IKAMMKLBOCO(betterproto.Message): + type: "MissionSyncRecord" = betterproto.enum_field(6) + id: int = betterproto.uint32_field(9) + display_value: int = betterproto.uint32_field(15) + + +@dataclass +class Mission(betterproto.Message): + progress: int = betterproto.uint32_field(1) + status: "MissionStatus" = betterproto.enum_field(13) + id: int = betterproto.uint32_field(5) + + +@dataclass +class MissionCustomValue(betterproto.Message): + dfdekanjblg: str = betterproto.string_field(4) + index: int = betterproto.uint32_field(5) + custom_value: int = betterproto.uint32_field(6) + + +@dataclass +class MissionCustomValueList(betterproto.Message): + custom_value_list: List["MissionCustomValue"] = betterproto.message_field(15) + + +@dataclass +class MainMission(betterproto.Message): + status: "MissionStatus" = betterproto.enum_field(10) + id: int = betterproto.uint32_field(3) + custom_value_list: List["MissionCustomValue"] = betterproto.message_field(6) + + +@dataclass +class FHABEIKAFBO(betterproto.Message): + custom_value_list: "MissionCustomValueList" = betterproto.message_field( + 188 + ) + id: int = betterproto.uint32_field(7) + + +@dataclass +class MainMissionCustomValue(betterproto.Message): + main_mission_id: int = betterproto.uint32_field(13) + custom_value_list: "MissionCustomValueList" = betterproto.message_field(12) + + +@dataclass +class GetMissionDataScRsp(betterproto.Message): + track_mission_id: int = betterproto.uint32_field(13) + mission_list: List["Mission"] = betterproto.message_field(3) + main_mission_list: List["MainMission"] = betterproto.message_field(14) + retcode: int = betterproto.uint32_field(2) + ojomocgiaic: List[int] = betterproto.uint32_field(9) + + +@dataclass +class AcceptMainMissionCsReq(betterproto.Message): + main_mission_id: int = betterproto.uint32_field(14) + + +@dataclass +class AcceptMainMissionScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(3) + main_mission_id: int = betterproto.uint32_field(13) + + +@dataclass +class FinishTalkMissionCsReq(betterproto.Message): + sub_mission_id: int = betterproto.uint32_field(1) + custom_value_list: List["MissionCustomValue"] = betterproto.message_field(6) + talk_str: str = betterproto.string_field(2) + + +@dataclass +class FinishTalkMissionScRsp(betterproto.Message): + custom_value_list: List["MissionCustomValue"] = betterproto.message_field(4) + talk_str: str = betterproto.string_field(1) + retcode: int = betterproto.uint32_field(3) + sub_mission_id: int = betterproto.uint32_field(15) + + +@dataclass +class MissionRewardScNotify(betterproto.Message): + sub_mission_id: int = betterproto.uint32_field(8) + main_mission_id: int = betterproto.uint32_field(14) + reward: "ItemList" = betterproto.message_field(13) + + +@dataclass +class SubMissionRewardScNotify(betterproto.Message): + reward: "ItemList" = betterproto.message_field(13) + sub_mission_id: int = betterproto.uint32_field(9) + + +@dataclass +class SyncTaskCsReq(betterproto.Message): + key: str = betterproto.string_field(5) + + +@dataclass +class SyncTaskScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(7) + key: str = betterproto.string_field(5) + + +@dataclass +class MissionGroupWarnScNotify(betterproto.Message): + group_id_list: List[int] = betterproto.uint32_field(2) + + +@dataclass +class FinishCosumeItemMissionCsReq(betterproto.Message): + item_list: "ItemList" = betterproto.message_field(4) + sub_mission_id: int = betterproto.uint32_field(2) + + +@dataclass +class FinishCosumeItemMissionScRsp(betterproto.Message): + sub_mission_id: int = betterproto.uint32_field(11) + retcode: int = betterproto.uint32_field(15) + + +@dataclass +class GetMissionStatusCsReq(betterproto.Message): + main_mission_id_list: List[int] = betterproto.uint32_field(3) + sub_mission_id_list: List[int] = betterproto.uint32_field(10) + + +@dataclass +class GetMissionStatusScRsp(betterproto.Message): + curversion_finished_main_mission_id_list: List[int] = betterproto.uint32_field(8) + sub_mission_status_list: List["Mission"] = betterproto.message_field(7) + finished_main_mission_id_list: List[int] = betterproto.uint32_field(13) + disabled_main_mission_id_list: List[int] = betterproto.uint32_field(11) + unfinished_main_mission_id_list: List[int] = betterproto.uint32_field(5) + main_mission_mcv_list: List["MainMissionCustomValue"] = betterproto.message_field( + 12 + ) + retcode: int = betterproto.uint32_field(6) + + +@dataclass +class TeleportToMissionResetPointCsReq(betterproto.Message): + pass + + +@dataclass +class TeleportToMissionResetPointScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(5) + client_pos_version: int = betterproto.uint32_field(15) + motion: "MotionInfo" = betterproto.message_field(9) + + +@dataclass +class StartFinishSubMissionScNotify(betterproto.Message): + sub_mission_id: int = betterproto.uint32_field(7) + + +@dataclass +class StartFinishMainMissionScNotify(betterproto.Message): + main_mission_id: int = betterproto.uint32_field(9) + + +@dataclass +class GetMainMissionCustomValueCsReq(betterproto.Message): + main_mission_id_list: List[int] = betterproto.uint32_field(1) + + +@dataclass +class GetMainMissionCustomValueScRsp(betterproto.Message): + main_mission_list: List["MainMission"] = betterproto.message_field(13) + retcode: int = betterproto.uint32_field(3) + + +@dataclass +class MissionAcceptScNotify(betterproto.Message): + sub_mission_id_list: List[int] = betterproto.uint32_field(9) + + +@dataclass +class UpdateTrackMainMissionIdCsReq(betterproto.Message): + lmbceopcigc: int = betterproto.uint32_field(11) + ijdjmnjbobi: "TrackMainMissionUpdateReasonId" = betterproto.enum_field(3) + track_mission_id: int = betterproto.uint32_field(8) + + +@dataclass +class UpdateTrackMainMissionIdScRsp(betterproto.Message): + track_mission_id: int = betterproto.uint32_field(8) + prev_track_mission_id: int = betterproto.uint32_field(6) + retcode: int = betterproto.uint32_field(14) + + +@dataclass +class FinishedMissionScNotify(betterproto.Message): + finished_main_mission_id_list: List[int] = betterproto.uint32_field(11) + + +@dataclass +class PILPBOGGLKO(betterproto.Message): + dfdekanjblg: str = betterproto.string_field(11) + main_mission_id: int = betterproto.uint32_field(1) + value: int = betterproto.uint32_field(14) + + +@dataclass +class AMNJJPCIGLJ(betterproto.Message): + lpjfbmjbepp: "MainMission" = betterproto.message_field(7) + retcode: int = betterproto.uint32_field(4) + + +@dataclass +class GetMonopolyInfoCsReq(betterproto.Message): + pass + + +@dataclass +class ODAIJIGEAJL(betterproto.Message): + ljfgifbdanc: bool = betterproto.bool_field(1) + ejhdcneegmi: int = betterproto.uint32_field(15) + fljbjpahjif: int = betterproto.uint32_field(13) + engjfichdml: int = betterproto.uint32_field(9) + item_value: int = betterproto.uint32_field(8) + hgmmchhbkpb: bool = betterproto.bool_field(4) + + +@dataclass +class LLGNIKNMCKE(betterproto.Message): + ofiodjnlbea: List[int] = betterproto.uint32_field(11) + nmamonllall: "GOJOINDBKIK" = betterproto.enum_field(6) + + +@dataclass +class OOEMIBFNLLD(betterproto.Message): + progress: int = betterproto.uint32_field(12) + ekpnclpoenk: int = betterproto.uint32_field(7) + + +@dataclass +class LAILNIGFPOO(betterproto.Message): + aelpfebgnok: bool = betterproto.bool_field(2) + khgpfhboele: int = betterproto.uint64_field(6) + is_taken_reward: bool = betterproto.bool_field(8) + + +@dataclass +class BCMOKFHJMPM(betterproto.Message): + cjfmaiakenl: List["OOEMIBFNLLD"] = betterproto.message_field(1) + hhjpblekapn: int = betterproto.uint32_field(11) + ddibefmilmp: str = betterproto.string_field(822) + eboolgnacjj: int = betterproto.uint64_field(6) + pjdfbpbmbba: str = betterproto.string_field(1618) + jgnihljfjpp: int = betterproto.uint32_field(4) + ebabbejipjn: List["LAILNIGFPOO"] = betterproto.message_field(10) + bnoldnbmjhf: int = betterproto.uint32_field(13) + ljjmleioife: int = betterproto.uint32_field(14) + jlegpnihmjd: str = betterproto.string_field(1852) + dgepmkffoab: int = betterproto.uint32_field(12) + omgkjljihlh: int = betterproto.uint64_field(5) + fholfdonoii: bool = betterproto.bool_field(3) + jckngfjeegi: List["OOEMIBFNLLD"] = betterproto.message_field(2) + kgbejknclfk: List["OOEMIBFNLLD"] = betterproto.message_field(8) + jojndgbejek: int = betterproto.uint64_field(15) + ifkfepkhlgn: List["OOEMIBFNLLD"] = betterproto.message_field(9) + dgalcmfidfp: int = betterproto.uint32_field(7) + + +@dataclass +class EDKGOMNEHOH(betterproto.Message): + fjoafflleok: List["BCMOKFHJMPM"] = betterproto.message_field(4) + + +@dataclass +class GetMonopolyInfoScRsp(betterproto.Message): + cokcgfmeiba: List[int] = betterproto.uint32_field(6) + hehjkfilinn: "NFDGIJLOLGD" = betterproto.message_field(13) + jnhjeeljfhf: "LLGNIKNMCKE" = betterproto.message_field(4) + stt: "KJBMLBGIBJF" = betterproto.message_field(9) + hljmhnabfmc: "ODAIJIGEAJL" = betterproto.message_field(14) + oelhkeipidj: "CANNIBGCLCL" = betterproto.message_field(12) + fghciadcmnj: "HFDGMJJFOHM" = betterproto.message_field(8) + retcode: int = betterproto.uint32_field(3) + ljaogapdfha: "AEDKPBFCKGO" = betterproto.message_field(5) + rogue_buff_info: "AFDALBGANPC" = betterproto.message_field(15) + rogue_map: "JAJGKKDPALC" = betterproto.message_field(2) + gpfgdokngel: "ICIHABOLHPN" = betterproto.message_field(7) + iedgkhdjjdc: "EDKGOMNEHOH" = betterproto.message_field(11) + + +@dataclass +class NFDGIJLOLGD(betterproto.Message): + hfmdlhifmpi: List[int] = betterproto.uint32_field(9) + + +@dataclass +class MonopolyConditionUpdateScNotify(betterproto.Message): + hehjkfilinn: "NFDGIJLOLGD" = betterproto.message_field(10) + + +@dataclass +class KJBMLBGIBJF(betterproto.Message): + jihchilfjpi: List[int] = betterproto.uint32_field(13) + occmnidebbj: List[int] = betterproto.uint32_field(9) + + +@dataclass +class MonopolySttUpdateScNotify(betterproto.Message): + stt: "KJBMLBGIBJF" = betterproto.message_field(11) + + +@dataclass +class IAACCAFGEPI(betterproto.Message): + map_id: int = betterproto.uint32_field(15) + cell_id: int = betterproto.uint32_field(7) + mafkcbodmmc: "IHGJLLNGDKL" = betterproto.enum_field(11) + jmdeflafice: bool = betterproto.bool_field(14) + + +@dataclass +class JAJGKKDPALC(betterproto.Message): + hgbigbfgbom: "IAACCAFGEPI" = betterproto.message_field(4) + lbbonkacgej: int = betterproto.uint32_field(13) + nbmpbgpjonh: List["IAACCAFGEPI"] = betterproto.message_field(1) + imopiejbhod: List["IAACCAFGEPI"] = betterproto.message_field(15) + pgalbdiiefg: int = betterproto.uint32_field(7) + + +@dataclass +class MonopolyEventLoadUpdateScNotify(betterproto.Message): + nbmpbgpjonh: List["IAACCAFGEPI"] = betterproto.message_field(6) + imopiejbhod: List["IAACCAFGEPI"] = betterproto.message_field(10) + + +@dataclass +class COMEOLGLNKO(betterproto.Message): + event_id: int = betterproto.uint32_field(10) + + +@dataclass +class PBLCEJHPOPO(betterproto.Message): + event_id: int = betterproto.uint32_field(4) + + +@dataclass +class LIHOCEHEPDB(betterproto.Message): + event_id: int = betterproto.uint32_field(6) + lfcmbgoaibb: int = betterproto.uint32_field(12) + hfejhlniggh: List[int] = betterproto.uint32_field(13) + option_id: int = betterproto.uint32_field(1) + + +@dataclass +class OHNBCHLOEBL(betterproto.Message): + lfcmbgoaibb: int = betterproto.uint32_field(5) + event_id: int = betterproto.uint32_field(8) + hfejhlniggh: List[int] = betterproto.uint32_field(9) + eccjbglbigm: int = betterproto.uint32_field(13) + olfnjjklgmk: int = betterproto.uint32_field(11) + + +@dataclass +class BLMJNFFPMCN(betterproto.Message): + pifpgkffbpn: int = betterproto.uint32_field(7) + kmkfojahelj: List["LBENAAHCPEO"] = betterproto.message_field(13) + + +@dataclass +class AAIBAKECHCE(betterproto.Message): + pagcamagflb: int = betterproto.uint32_field(14) + + +@dataclass +class FGONFNIDOHJ(betterproto.Message): + shop_id: int = betterproto.uint32_field(10) + + +@dataclass +class IPONFKAJENJ(betterproto.Message): + apaobdgjmeg: int = betterproto.uint32_field(8) + + +@dataclass +class NALPJMLJPNP(betterproto.Message): + oefhmbjblgc: int = betterproto.uint32_field(8) + get_item_list: int = betterproto.uint32_field(6) + + +@dataclass +class LBENAAHCPEO(betterproto.Message): + pecbimkooah: "COMEOLGLNKO" = betterproto.message_field(3) + emlnnmlgnkh: "PBLCEJHPOPO" = betterproto.message_field(7) + jbjldppdbbc: "LIHOCEHEPDB" = betterproto.message_field(12) + ecoifnnjdap: "AAIBAKECHCE" = betterproto.message_field(9) + nbjicdajdgf: "FGONFNIDOHJ" = betterproto.message_field(2) + gajbfpcpigm: "IPONFKAJENJ" = betterproto.message_field(1) + joppaemppfh: "NALPJMLJPNP" = betterproto.message_field(14) + joadhbldimf: "OHNBCHLOEBL" = betterproto.message_field(4) + iefoghngcmc: "BLMJNFFPMCN" = betterproto.message_field(13) + o_k_d_l_m_e_j_p_c_h_e: int = betterproto.uint32_field(11) + + +@dataclass +class ICIHABOLHPN(betterproto.Message): + fhnpagihinf: "LBENAAHCPEO" = betterproto.message_field(14) + + +@dataclass +class MonopolyContentUpdateScNotify(betterproto.Message): + fhnpagihinf: "LBENAAHCPEO" = betterproto.message_field(7) + + +@dataclass +class MonopolyCellUpdateNotify(betterproto.Message): + hgbigbfgbom: "IAACCAFGEPI" = betterproto.message_field(3) + + +@dataclass +class MonopolyRollDiceCsReq(betterproto.Message): + pass + + +@dataclass +class MonopolyRollDiceScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(3) + blhiabbkgpb: int = betterproto.uint32_field(14) + + +@dataclass +class MonopolyCheatDiceCsReq(betterproto.Message): + ocfhhdcbfbh: int = betterproto.uint32_field(12) + + +@dataclass +class MonopolyCheatDiceScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(7) + ocfhhdcbfbh: int = betterproto.uint32_field(12) + + +@dataclass +class MonopolyMoveCsReq(betterproto.Message): + dgbmdpbialg: int = betterproto.uint32_field(14) + cnifhnbiofj: int = betterproto.uint32_field(4) + + +@dataclass +class MonopolyMoveScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(10) + rogue_map: "JAJGKKDPALC" = betterproto.message_field(13) + hecjnjniakk: List["IAACCAFGEPI"] = betterproto.message_field(11) + + +@dataclass +class MonopolySelectOptionCsReq(betterproto.Message): + event_id: int = betterproto.uint32_field(11) + option_id: int = betterproto.uint32_field(12) + + +@dataclass +class DDCELCOJGNP(betterproto.Message): + option_id: int = betterproto.uint32_field(8) + event_id: int = betterproto.uint32_field(11) + lgiiahidlmg: int = betterproto.uint32_field(1) + + +@dataclass +class MonopolySelectOptionScRsp(betterproto.Message): + option_id: int = betterproto.uint32_field(8) + gpfgdokngel: "LBENAAHCPEO" = betterproto.message_field(13) + event_id: int = betterproto.uint32_field(7) + abnoinlokln: List["DDCELCOJGNP"] = betterproto.message_field(4) + retcode: int = betterproto.uint32_field(14) + + +@dataclass +class MonopolyRollRandomCsReq(betterproto.Message): + event_id: int = betterproto.uint32_field(1) + + +@dataclass +class MonopolyRollRandomScRsp(betterproto.Message): + gpfgdokngel: "LBENAAHCPEO" = betterproto.message_field(15) + event_id: int = betterproto.uint32_field(12) + retcode: int = betterproto.uint32_field(6) + + +@dataclass +class MonopolyReRollRandomCsReq(betterproto.Message): + event_id: int = betterproto.uint32_field(13) + + +@dataclass +class MonopolyReRollRandomScRsp(betterproto.Message): + event_id: int = betterproto.uint32_field(6) + gpfgdokngel: "LBENAAHCPEO" = betterproto.message_field(1) + retcode: int = betterproto.uint32_field(10) + + +@dataclass +class MonopolyConfirmRandomCsReq(betterproto.Message): + event_id: int = betterproto.uint32_field(7) + + +@dataclass +class MonopolyConfirmRandomScRsp(betterproto.Message): + event_id: int = betterproto.uint32_field(15) + retcode: int = betterproto.uint32_field(11) + gpfgdokngel: "LBENAAHCPEO" = betterproto.message_field(3) + + +@dataclass +class MonopolyBuyGoodsCsReq(betterproto.Message): + goods_id: int = betterproto.uint32_field(7) + shop_id: int = betterproto.uint32_field(14) + + +@dataclass +class MonopolyBuyGoodsScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(12) + goods_id: int = betterproto.uint32_field(7) + shop_id: int = betterproto.uint32_field(2) + + +@dataclass +class MonopolyUpgradeAssetCsReq(betterproto.Message): + pagcamagflb: int = betterproto.uint32_field(7) + + +@dataclass +class MonopolyUpgradeAssetScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(5) + pagcamagflb: int = betterproto.uint32_field(3) + + +@dataclass +class MonopolyGiveUpCurContentCsReq(betterproto.Message): + content_id: int = betterproto.uint32_field(11) + + +@dataclass +class MonopolyGiveUpCurContentScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(11) + content_id: int = betterproto.uint32_field(10) + + +@dataclass +class MonopolyActionResult(betterproto.Message): + trigger_cell_id: int = betterproto.uint32_field(1) + detail: "NIBJAMFMEFD" = betterproto.message_field(2) + click_map_id: int = betterproto.uint32_field(5) + trigger_map_id: int = betterproto.uint32_field(3) + effect_type: int = betterproto.uint32_field(13) + source_type: "GKEJFKAKENM" = betterproto.enum_field(6) + click_cell_id: int = betterproto.uint32_field(4) + + +@dataclass +class MonopolyActionResultScNotify(betterproto.Message): + pfnokncdpge: List["MonopolyActionResult"] = betterproto.message_field(13) + + +@dataclass +class LMMEBMBGLDN(betterproto.Message): + hkmihejcaem: int = betterproto.uint32_field(3) + blhdohmacbm: bool = betterproto.bool_field(8) + + +@dataclass +class NIBJAMFMEFD(betterproto.Message): + mecllcdabno: "LMKAAEFPFFO" = betterproto.message_field(5) + ffipkmhckhj: "LMKAAEFPFFO" = betterproto.message_field(6) + nfbcgknopda: "AIDFBBIAPEP" = betterproto.message_field(2) + dachanhppbg: "AIDFBBIAPEP" = betterproto.message_field(7) + get_buff_list: "BMPLFJKEOLF" = betterproto.message_field(4) + remove_buff_list: "BMPLFJKEOLF" = betterproto.message_field(1) + dmdpcooafjk: "LNKMKNBPIJH" = betterproto.message_field(12) + hhibfnagkff: "LNKMKNBPIJH" = betterproto.message_field(3) + nkcmgbcpjgg: "LMMEBMBGLDN" = betterproto.message_field(15) + hanogacjpkb: "LPBAMOKKJCM" = betterproto.message_field(13) + omfecimladc: "BMPLFJKEOLF" = betterproto.message_field(9) + ngonccblaol: "LNKMKNBPIJH" = betterproto.message_field(8) + fjghnlnjlph: "NMGHFOLKFAJ" = betterproto.message_field(14) + + +@dataclass +class NMGHFOLKFAJ(betterproto.Message): + gjlkoggiifo: int = betterproto.uint32_field(5) + + +@dataclass +class LMKAAEFPFFO(betterproto.Message): + ogjofmcmfpg: int = betterproto.uint32_field(11) + bmalpkekbel: int = betterproto.uint32_field(15) + item_id: int = betterproto.uint32_field(14) + + +@dataclass +class LNKMKNBPIJH(betterproto.Message): + ognkmdnjgog: int = betterproto.uint32_field(9) + igdbofcdjol: int = betterproto.uint32_field(10) + + +@dataclass +class LPBAMOKKJCM(betterproto.Message): + knggppiogae: int = betterproto.uint32_field(3) + hnlfmjoknbn: int = betterproto.uint32_field(9) + mdflfllmgna: int = betterproto.uint32_field(4) + njdggjbefcn: int = betterproto.uint32_field(10) + + +@dataclass +class HAKNOFDPBOD(betterproto.Message): + ejcolgnjgdc: "GJKIAPIPGAN" = betterproto.message_field(10) + lkaniplnkgc: "EIMOBGLLEFO" = betterproto.message_field(15) + bdempakhgmj: "EOPFMPAOOJE" = betterproto.message_field(8) + config_id: int = betterproto.uint32_field(14) + a_c_d_o_p_c_b_m_p_n_l: int = betterproto.uint32_field(7) + f_p_o_g_i_a_l_m_c_i_p: int = betterproto.uint32_field(12) + + +@dataclass +class HFDGMJJFOHM(betterproto.Message): + npoigjpcgfb: "LMMEBMBGLDN" = betterproto.message_field(4) + ajcinkhbdjb: "HAKNOFDPBOD" = betterproto.message_field(13) + pefmdfkecod: List["HAKNOFDPBOD"] = betterproto.message_field(9) + + +@dataclass +class MonopolyGameSettleScNotify(betterproto.Message): + item_list: "ItemList" = betterproto.message_field(2) + pemijimjmio: "ItemList" = betterproto.message_field(10) + gajbfpcpigm: "HAKNOFDPBOD" = betterproto.message_field(1) + + +@dataclass +class MonopolyGameCreateScNotify(betterproto.Message): + gajbfpcpigm: "HAKNOFDPBOD" = betterproto.message_field(9) + npoigjpcgfb: "LMMEBMBGLDN" = betterproto.message_field(5) + + +@dataclass +class MonopolyGameRaiseRatioCsReq(betterproto.Message): + acdopcbmpnl: int = betterproto.uint32_field(15) + + +@dataclass +class MonopolyGameRaiseRatioScRsp(betterproto.Message): + ratio: int = betterproto.uint32_field(12) + retcode: int = betterproto.uint32_field(2) + + +@dataclass +class DailyFirstEnterMonopolyActivityCsReq(betterproto.Message): + pass + + +@dataclass +class DailyFirstEnterMonopolyActivityScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(4) + iihkiklioji: int = betterproto.int64_field(5) + ljaogapdfha: "AEDKPBFCKGO" = betterproto.message_field(13) + oicaghgmmfp: bool = betterproto.bool_field(3) + kekjcdmiddl: int = betterproto.uint32_field(1) + + +@dataclass +class MonopolyGetDailyInitItemCsReq(betterproto.Message): + ifhpjjblndl: bool = betterproto.bool_field(15) + + +@dataclass +class MonopolyGetDailyInitItemScRsp(betterproto.Message): + heoofpgkdcd: int = betterproto.uint32_field(13) + hbfffgpjkic: int = betterproto.uint32_field(3) + ofgnignohaf: int = betterproto.uint32_field(5) + hcdbbflpcfl: int = betterproto.uint32_field(12) + ioabhfpabbe: int = betterproto.uint32_field(10) + retcode: int = betterproto.uint32_field(4) + iihkiklioji: int = betterproto.int64_field(2) + + +@dataclass +class GJKIAPIPGAN(betterproto.Message): + nfeadmfnflk: bool = betterproto.bool_field(3) + pogemmicila: List[int] = betterproto.uint32_field(15) + leghknnkomg: List[int] = betterproto.uint32_field(11) + oefjmefpipl: int = betterproto.uint32_field(8) + fhbopepjaen: List[int] = betterproto.uint32_field(1) + + +@dataclass +class MonopolyGameBingoFlipCardCsReq(betterproto.Message): + hcfpofmdgkn: int = betterproto.uint32_field(1) + + +@dataclass +class MonopolyGameBingoFlipCardScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(2) + leghknnkomg: List[int] = betterproto.uint32_field(9) + nfeadmfnflk: bool = betterproto.bool_field(3) + npjeecedpok: int = betterproto.uint32_field(14) + + +@dataclass +class MonopolyGameGachaCsReq(betterproto.Message): + pass + + +@dataclass +class MonopolyGameGachaScRsp(betterproto.Message): + result_list: List[int] = betterproto.uint32_field(3) + retcode: int = betterproto.uint32_field(13) + + +@dataclass +class NKACIMEOAPD(betterproto.Message): + ibadobadhjh: int = betterproto.uint32_field(11) + pogjhkfbmch: int = betterproto.uint32_field(4) + + +@dataclass +class EIMOBGLLEFO(betterproto.Message): + hpnhhcmkjcb: List[int] = betterproto.uint32_field(9) + bhpfpejbkec: int = betterproto.uint32_field(1) + ndggacpicbf: List["NKACIMEOAPD"] = betterproto.message_field(10) + chjngdioome: int = betterproto.uint32_field(5) + ohlepkekmnh: int = betterproto.uint32_field(4) + eaejlofgafo: int = betterproto.uint32_field(13) + + +@dataclass +class MonopolyAcceptQuizCsReq(betterproto.Message): + ndggacpicbf: List["NKACIMEOAPD"] = betterproto.message_field(14) + + +@dataclass +class MonopolyAcceptQuizScRsp(betterproto.Message): + lkaniplnkgc: "EIMOBGLLEFO" = betterproto.message_field(8) + retcode: int = betterproto.uint32_field(6) + + +@dataclass +class OOCKALNFHNP(betterproto.Message): + hmcjobjbpkj: int = betterproto.uint32_field(2) + chjngdioome: int = betterproto.uint32_field(1) + bgbihidhcon: int = betterproto.uint32_field(8) + + +@dataclass +class MonopolyQuizDurationChangeScNotify(betterproto.Message): + leadmneimdp: List["OOCKALNFHNP"] = betterproto.message_field(13) + + +@dataclass +class EOPFMPAOOJE(betterproto.Message): + lopdbaegfkp: bool = betterproto.bool_field(8) + hmhjdbifgdi: int = betterproto.uint32_field(3) + ppclbdbjlmo: int = betterproto.uint32_field(4) + + +@dataclass +class MonopolyGuessChooseCsReq(betterproto.Message): + hmhjdbifgdi: int = betterproto.uint32_field(13) + + +@dataclass +class MonopolyGuessChooseScRsp(betterproto.Message): + hmhjdbifgdi: int = betterproto.uint32_field(7) + retcode: int = betterproto.uint32_field(15) + + +@dataclass +class ACKNCAAAMJM(betterproto.Message): + ppclbdbjlmo: int = betterproto.uint32_field(12) + item_list: "ItemList" = betterproto.message_field(4) + giacfcddjnm: int = betterproto.uint32_field(3) + + +@dataclass +class MonopolyGuessDrawScNotify(betterproto.Message): + jhiikpejeie: List["ACKNCAAAMJM"] = betterproto.message_field(14) + + +@dataclass +class MonopolyGuessBuyInformationCsReq(betterproto.Message): + pass + + +@dataclass +class MonopolyGuessBuyInformationScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(11) + + +@dataclass +class AIDFBBIAPEP(betterproto.Message): + milkeacflpo: int = betterproto.uint32_field(5) + level: int = betterproto.uint32_field(2) + pagcamagflb: int = betterproto.uint32_field(4) + + +@dataclass +class CANNIBGCLCL(betterproto.Message): + magefljgjnd: List["AIDFBBIAPEP"] = betterproto.message_field(5) + + +@dataclass +class AEDKPBFCKGO(betterproto.Message): + kmgiemofogb: int = betterproto.uint32_field(13) + pddngkncpeb: int = betterproto.uint32_field(7) + pilaagokaof: int = betterproto.uint32_field(1) + gimdhbnjooo: int = betterproto.uint32_field(3) + ifkdgebcdeg: int = betterproto.uint32_field(5) + fnigpgbgehn: int = betterproto.uint32_field(11) + pkdlkcbkkpf: int = betterproto.uint32_field(15) + imoblgoajcb: bool = betterproto.bool_field(8) + efinfpkkjle: int = betterproto.uint32_field(2) + + +@dataclass +class MonopolyDailySettleScNotify(betterproto.Message): + kekjcdmiddl: int = betterproto.uint32_field(6) + ljaogapdfha: "AEDKPBFCKGO" = betterproto.message_field(3) + + +@dataclass +class BMPLFJKEOLF(betterproto.Message): + okdlmejpche: int = betterproto.uint32_field(1) + coffebnibhk: int = betterproto.uint32_field(13) + buff_id: int = betterproto.uint32_field(12) + + +@dataclass +class AFDALBGANPC(betterproto.Message): + buff_list: List["BMPLFJKEOLF"] = betterproto.message_field(6) + + +@dataclass +class INDGLKCECDC(betterproto.Message): + hdilbdipgho: int = betterproto.uint32_field(11) + fnigpgbgehn: int = betterproto.uint32_field(12) + dpjkojgcjlp: int = betterproto.uint32_field(5) + uid: int = betterproto.uint32_field(10) + pilaagokaof: int = betterproto.uint32_field(4) + + +@dataclass +class GetMonopolyFriendRankingListCsReq(betterproto.Message): + pass + + +@dataclass +class GetMonopolyFriendRankingListScRsp(betterproto.Message): + icmgegefdle: "INDGLKCECDC" = betterproto.message_field(9) + retcode: int = betterproto.uint32_field(1) + dcfhgaajlnn: List["INDGLKCECDC"] = betterproto.message_field(13) + + +@dataclass +class MonopolyLikeCsReq(betterproto.Message): + cbegnbkmhcd: int = betterproto.uint32_field(12) + + +@dataclass +class MonopolyLikeScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(8) + cbegnbkmhcd: int = betterproto.uint32_field(3) + reward_list: "ItemList" = betterproto.message_field(4) + + +@dataclass +class MonopolyLikeScNotify(betterproto.Message): + ofiodjnlbea: List[int] = betterproto.uint32_field(15) + hdilbdipgho: int = betterproto.uint32_field(2) + + +@dataclass +class GetMbtiReportCsReq(betterproto.Message): + pass + + +@dataclass +class MFDKINPDMKE(betterproto.Message): + cnt: int = betterproto.uint32_field(10) + fioepgpebfd: int = betterproto.uint32_field(12) + + +@dataclass +class GetMbtiReportScRsp(betterproto.Message): + gmdhhogbacn: List["MFDKINPDMKE"] = betterproto.message_field(13) + ljhaifciabh: int = betterproto.int32_field(9) + phnkkellanm: int = betterproto.int32_field(12) + abnoinlokln: List["DDCELCOJGNP"] = betterproto.message_field(7) + retcode: int = betterproto.uint32_field(10) + progress: int = betterproto.uint32_field(14) + pcadcgcelin: bool = betterproto.bool_field(5) + is_taken_reward: bool = betterproto.bool_field(1) + + +@dataclass +class MonopolyEventSelectFriendCsReq(betterproto.Message): + ipgeclelhgj: int = betterproto.uint32_field(15) + bagmaoipmje: bool = betterproto.bool_field(5) + + +@dataclass +class MonopolyEventSelectFriendScRsp(betterproto.Message): + get_item_list: int = betterproto.uint32_field(14) + retcode: int = betterproto.uint32_field(3) + oefhmbjblgc: int = betterproto.uint32_field(2) + hgbigbfgbom: "IAACCAFGEPI" = betterproto.message_field(7) + + +@dataclass +class SocialEventServerCache(betterproto.Message): + id: int = betterproto.uint32_field(1) + sub_coin: int = betterproto.uint32_field(6) + src_uid: int = betterproto.uint32_field(12) + add_coin: int = betterproto.uint32_field(8) + + +@dataclass +class MonopolySocialEventEffectScNotify(betterproto.Message): + miaeaffdgmh: List["SocialEventServerCache"] = betterproto.message_field(2) + + +@dataclass +class GetSocialEventServerCacheCsReq(betterproto.Message): + pass + + +@dataclass +class GetSocialEventServerCacheScRsp(betterproto.Message): + miaeaffdgmh: List["SocialEventServerCache"] = betterproto.message_field(12) + retcode: int = betterproto.uint32_field(4) + + +@dataclass +class DeleteSocialEventServerCacheCsReq(betterproto.Message): + jiddlnhjnpb: List[int] = betterproto.uint32_field(6) + + +@dataclass +class DeleteSocialEventServerCacheScRsp(betterproto.Message): + bfgjmmpcpnj: List[int] = betterproto.uint32_field(3) + retcode: int = betterproto.uint32_field(9) + + +@dataclass +class MonopolyGetRaffleTicketCsReq(betterproto.Message): + hhjpblekapn: int = betterproto.uint32_field(11) + + +@dataclass +class MonopolyGetRaffleTicketScRsp(betterproto.Message): + hhjpblekapn: int = betterproto.uint32_field(7) + retcode: int = betterproto.uint32_field(11) + blmedlnokei: List["LAILNIGFPOO"] = betterproto.message_field(1) + + +@dataclass +class MonopolyTakeRaffleTicketRewardCsReq(betterproto.Message): + hhjpblekapn: int = betterproto.uint32_field(7) + pmelcdfhgkc: int = betterproto.uint64_field(5) + + +@dataclass +class MonopolyTakeRaffleTicketRewardScRsp(betterproto.Message): + reward_list: "ItemList" = betterproto.message_field(7) + retcode: int = betterproto.uint32_field(9) + hhjpblekapn: int = betterproto.uint32_field(11) + pmelcdfhgkc: int = betterproto.uint32_field(14) + + +@dataclass +class MonopolyScrachRaffleTicketCsReq(betterproto.Message): + pmelcdfhgkc: int = betterproto.uint64_field(6) + hhjpblekapn: int = betterproto.uint32_field(12) + + +@dataclass +class MonopolyScrachRaffleTicketScRsp(betterproto.Message): + pmelcdfhgkc: int = betterproto.uint64_field(8) + hhjpblekapn: int = betterproto.uint32_field(15) + retcode: int = betterproto.uint32_field(6) + + +@dataclass +class MonopolyGetRegionProgressCsReq(betterproto.Message): + pass + + +@dataclass +class MonopolyGetRegionProgressScRsp(betterproto.Message): + eimgbknlgnf: int = betterproto.uint32_field(6) + retcode: int = betterproto.uint32_field(2) + dpjkojgcjlp: int = betterproto.uint32_field(11) + + +@dataclass +class MonopolyGetRafflePoolInfoCsReq(betterproto.Message): + pass + + +@dataclass +class MonopolyGetRafflePoolInfoScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(3) + iedgkhdjjdc: "EDKGOMNEHOH" = betterproto.message_field(4) + + +@dataclass +class MonopolyTakePhaseRewardCsReq(betterproto.Message): + ljbgjhpkkjj: List[int] = betterproto.uint32_field(8) + + +@dataclass +class MonopolyTakePhaseRewardScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(14) + reward_list: "ItemList" = betterproto.message_field(6) + ljbgjhpkkjj: List[int] = betterproto.uint32_field(8) + + +@dataclass +class GetMonopolyMbtiReportRewardCsReq(betterproto.Message): + pass + + +@dataclass +class GetMonopolyMbtiReportRewardScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(10) + reward_list: "ItemList" = betterproto.message_field(1) + + +@dataclass +class GetMonopolyDailyReportCsReq(betterproto.Message): + pass + + +@dataclass +class GetMonopolyDailyReportScRsp(betterproto.Message): + ljaogapdfha: "AEDKPBFCKGO" = betterproto.message_field(12) + retcode: int = betterproto.uint32_field(15) + + +@dataclass +class MonopolyClickCellCsReq(betterproto.Message): + cell_id: int = betterproto.uint32_field(5) + map_id: int = betterproto.uint32_field(13) + + +@dataclass +class MonopolyClickCellScRsp(betterproto.Message): + cell_id: int = betterproto.uint32_field(1) + map_id: int = betterproto.uint32_field(4) + retcode: int = betterproto.uint32_field(11) + + +@dataclass +class MonopolyClickMbtiReportCsReq(betterproto.Message): + pass + + +@dataclass +class MonopolyClickMbtiReportScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(2) + + +@dataclass +class MultiplayerFightGameStateCsReq(betterproto.Message): + pass + + +@dataclass +class MultiplayerFightGameStateScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(3) + pfffjngnpom: "PPGGKMDAOEA" = betterproto.message_field(8) + lipjdjpmokb: List["CBBDIOMIFHD"] = betterproto.message_field(12) + + +@dataclass +class MultiplayerGetFightGateCsReq(betterproto.Message): + player_data: int = betterproto.uint32_field(13) + + +@dataclass +class MultiplayerGetFightGateScRsp(betterproto.Message): + nogfeemnhpc: int = betterproto.uint64_field(13) + aokcmmpfgbc: str = betterproto.string_field(15) + ip: str = betterproto.string_field(14) + retcode: int = betterproto.uint32_field(12) + port: int = betterproto.uint32_field(3) + + +@dataclass +class MultiplayerFightGiveUpCsReq(betterproto.Message): + nogfeemnhpc: int = betterproto.uint64_field(10) + + +@dataclass +class MultiplayerFightGiveUpScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(14) + + +@dataclass +class MultiplayerFightGameStartScNotify(betterproto.Message): + pfffjngnpom: "PPGGKMDAOEA" = betterproto.message_field(11) + lipjdjpmokb: List["CBBDIOMIFHD"] = betterproto.message_field(1) + + +@dataclass +class MultiplayerFightGameFinishScNotify(betterproto.Message): + pfffjngnpom: "PPGGKMDAOEA" = betterproto.message_field(15) + + +@dataclass +class MultiplayerMatch3FinishScNotify(betterproto.Message): + fdgdokafbdh: int = betterproto.uint32_field(9) + reason: "Match3FinishReason" = betterproto.enum_field(1) + kojihjihkia: int = betterproto.uint32_field(3) + niaeghjlnmb: "CDIMEMFJJFP" = betterproto.message_field(13) + + +@dataclass +class GetMultipleDropInfoCsReq(betterproto.Message): + pass + + +@dataclass +class ECCNNONKFCA(betterproto.Message): + id: int = betterproto.uint32_field(8) + olalhikmjop: int = betterproto.uint32_field(3) + + +@dataclass +class GetMultipleDropInfoScRsp(betterproto.Message): + ljcpdmnkjif: List["ECCNNONKFCA"] = betterproto.message_field(6) + fchnnkekfcl: List["OHDNCHFGFMA"] = betterproto.message_field(11) + retcode: int = betterproto.uint32_field(8) + + +@dataclass +class MultipleDropInfoScNotify(betterproto.Message): + ljcpdmnkjif: List["ECCNNONKFCA"] = betterproto.message_field(7) + + +@dataclass +class GetPlayerReturnMultiDropInfoCsReq(betterproto.Message): + pass + + +@dataclass +class JBFIPIJJIDL(betterproto.Message): + panel_id: int = betterproto.uint32_field(4) + ljkffdmhojh: int = betterproto.uint32_field(14) + pjhdjkmjpkh: int = betterproto.uint32_field(10) + dkjgcbjkeen: int = betterproto.uint32_field(8) + + +@dataclass +class OHDNCHFGFMA(betterproto.Message): + durability: int = betterproto.uint32_field(12) + panel_id: int = betterproto.uint32_field(14) + bjfbglbjbnn: int = betterproto.uint32_field(4) + lclmhegdggb: int = betterproto.uint32_field(1) + + +@dataclass +class GetPlayerReturnMultiDropInfoScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(1) + fchnnkekfcl: List["OHDNCHFGFMA"] = betterproto.message_field(6) + ikgfoejpjcf: "JBFIPIJJIDL" = betterproto.message_field(15) + + +@dataclass +class MultipleDropInfoNotify(betterproto.Message): + fchnnkekfcl: List["OHDNCHFGFMA"] = betterproto.message_field(12) + ponjjnddkbh: List["JBFIPIJJIDL"] = betterproto.message_field(11) + ljcpdmnkjif: List["ECCNNONKFCA"] = betterproto.message_field(15) + + +@dataclass +class OPGJGDOGGNJ(betterproto.Message): + pos: "KAMLGLMNJGJ" = betterproto.enum_field(8) + bdjcgcdjoeo: int = betterproto.uint32_field(7) + + +@dataclass +class JMEAOCPFEOL(betterproto.Message): + hjjfmdheapb: int = betterproto.uint32_field(12) + bojmnafdjkh: List["OPGJGDOGGNJ"] = betterproto.message_field(7) + hihlgaghlni: int = betterproto.uint32_field(4) + level: int = betterproto.uint32_field(6) + cdnngagbaak: int = betterproto.uint32_field(9) + area_id: int = betterproto.uint32_field(10) + + +@dataclass +class PANAIJBJMEN(betterproto.Message): + is_finish: bool = betterproto.bool_field(11) + beleodaiinb: int = betterproto.uint32_field(13) + + +@dataclass +class DOLGFNLHEAE(betterproto.Message): + fileddcmdoc: int = betterproto.uint32_field(4) + fnpphmblkoa: int = betterproto.uint32_field(2) + fmbfbgnaboc: List["PANAIJBJMEN"] = betterproto.message_field(7) + dcehogagkom: int = betterproto.uint32_field(9) + ggfddejhlif: int = betterproto.uint32_field(6) + pngddnajcgg: int = betterproto.uint32_field(14) + + +@dataclass +class OLKMLFEEFCJ(betterproto.Message): + bdjcgcdjoeo: int = betterproto.uint32_field(5) + lgkiielghdj: int = betterproto.uint32_field(1) + + +@dataclass +class BLNEHDIFMOO(betterproto.Message): + bmbgklkecaj: int = betterproto.uint32_field(14) + haabefkhami: List[int] = betterproto.uint32_field(4) + hcaglclejnd: int = betterproto.uint32_field(9) + state: "AIHADKBHPBM" = betterproto.enum_field(2) + cogbcplmnfd: int = betterproto.uint32_field(15) + event_id: int = betterproto.uint32_field(6) + dgjbacbiico: int = betterproto.uint32_field(3) + + +@dataclass +class JNBCPNCNOHO(betterproto.Message): + pnjeepoemca: List[int] = betterproto.uint32_field(4) + bjcmphlpknf: List["BLNEHDIFMOO"] = betterproto.message_field(11) + lhnjmbgndkc: int = betterproto.uint32_field(12) + + +@dataclass +class GetMuseumInfoCsReq(betterproto.Message): + pass + + +@dataclass +class GetMuseumInfoScRsp(betterproto.Message): + kndmdpefadc: List[int] = betterproto.uint32_field(3) + level: int = betterproto.uint32_field(5) + area_list: List["JMEAOCPFEOL"] = betterproto.message_field(2) + jpibmbbkgnd: "DOLGFNLHEAE" = betterproto.message_field(11) + bojmnafdjkh: List["OLKMLFEEFCJ"] = betterproto.message_field(7) + exp: int = betterproto.uint32_field(13) + cur_fund: int = betterproto.uint32_field(4) + retcode: int = betterproto.uint32_field(15) + kndjapnpapk: List[int] = betterproto.uint32_field(9) + ejnkmkffccl: int = betterproto.uint32_field(6) + ekkolcccnnk: "JNBCPNCNOHO" = betterproto.message_field(12) + hpnmpdocjma: int = betterproto.uint32_field(8) + ejkghbemoob: int = betterproto.uint32_field(1) + jbjldppdbbc: int = betterproto.uint32_field(10) + + +@dataclass +class BuyNpcStuffCsReq(betterproto.Message): + bdjcgcdjoeo: int = betterproto.uint32_field(12) + + +@dataclass +class BuyNpcStuffScRsp(betterproto.Message): + bdjcgcdjoeo: int = betterproto.uint32_field(8) + retcode: int = betterproto.uint32_field(9) + + +@dataclass +class SetStuffToAreaCsReq(betterproto.Message): + pos: "KAMLGLMNJGJ" = betterproto.enum_field(6) + bdjcgcdjoeo: int = betterproto.uint32_field(10) + lgkiielghdj: int = betterproto.uint32_field(14) + + +@dataclass +class SetStuffToAreaScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(1) + pos: "KAMLGLMNJGJ" = betterproto.enum_field(11) + lgkiielghdj: int = betterproto.uint32_field(9) + bdjcgcdjoeo: int = betterproto.uint32_field(5) + + +@dataclass +class RemoveStuffFromAreaCsReq(betterproto.Message): + bdjcgcdjoeo: int = betterproto.uint32_field(7) + + +@dataclass +class RemoveStuffFromAreaScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(2) + bdjcgcdjoeo: int = betterproto.uint32_field(6) + + +@dataclass +class GetStuffScNotify(betterproto.Message): + aocelkonhob: "KGJJJKPDCFG" = betterproto.enum_field(1) + bdjcgcdjoeo: int = betterproto.uint32_field(10) + + +@dataclass +class GetExhibitScNotify(betterproto.Message): + bccgcfmabgm: int = betterproto.uint32_field(2) + + +@dataclass +class FinishCurTurnCsReq(betterproto.Message): + cciecpfpfjg: int = betterproto.uint32_field(8) + + +@dataclass +class FinishCurTurnScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(10) + gpoieccpamn: int = betterproto.uint32_field(11) + + +@dataclass +class UpgradeAreaCsReq(betterproto.Message): + level: int = betterproto.uint32_field(1) + area_id: int = betterproto.uint32_field(12) + + +@dataclass +class UpgradeAreaScRsp(betterproto.Message): + area_id: int = betterproto.uint32_field(13) + level: int = betterproto.uint32_field(11) + retcode: int = betterproto.uint32_field(2) + + +@dataclass +class UpgradeAreaStatCsReq(betterproto.Message): + bojbpoelfci: "IBBGDGGHEJL" = betterproto.enum_field(5) + area_id: int = betterproto.uint32_field(3) + level: int = betterproto.uint32_field(12) + + +@dataclass +class UpgradeAreaStatScRsp(betterproto.Message): + level: int = betterproto.uint32_field(15) + bojbpoelfci: "IBBGDGGHEJL" = betterproto.enum_field(2) + retcode: int = betterproto.uint32_field(10) + area_id: int = betterproto.uint32_field(14) + + +@dataclass +class MuseumInfoChangedScNotify(betterproto.Message): + level: int = betterproto.uint32_field(14) + ejkghbemoob: int = betterproto.uint32_field(8) + exp: int = betterproto.uint32_field(10) + jbjldppdbbc: int = betterproto.uint32_field(5) + bojmnafdjkh: List["OLKMLFEEFCJ"] = betterproto.message_field(1) + ekkolcccnnk: "JNBCPNCNOHO" = betterproto.message_field(6) + kndmdpefadc: List[int] = betterproto.uint32_field(11) + cur_fund: int = betterproto.uint32_field(4) + area_list: List["JMEAOCPFEOL"] = betterproto.message_field(3) + hpnmpdocjma: int = betterproto.uint32_field(12) + ejnkmkffccl: int = betterproto.uint32_field(15) + kndjapnpapk: List[int] = betterproto.uint32_field(13) + jpibmbbkgnd: "DOLGFNLHEAE" = betterproto.message_field(2) + + +@dataclass +class MuseumRandomEventStartScNotify(betterproto.Message): + hndlhicdnpc: "BLNEHDIFMOO" = betterproto.message_field(10) + + +@dataclass +class MuseumRandomEventQueryCsReq(betterproto.Message): + cehfiilmjkm: int = betterproto.int32_field(7) + + +@dataclass +class MuseumRandomEventQueryScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(4) + hndlhicdnpc: "JNBCPNCNOHO" = betterproto.message_field(10) + + +@dataclass +class MuseumRandomEventSelectCsReq(betterproto.Message): + event_id: int = betterproto.uint32_field(8) + dgjbacbiico: int = betterproto.uint32_field(15) + + +@dataclass +class MuseumRandomEventSelectScRsp(betterproto.Message): + event_id: int = betterproto.uint32_field(10) + retcode: int = betterproto.uint32_field(3) + dgjbacbiico: int = betterproto.uint32_field(9) + + +@dataclass +class MuseumFundsChangedScNotify(betterproto.Message): + cur_fund: int = betterproto.uint32_field(2) + + +@dataclass +class MuseumDispatchFinishedScNotify(betterproto.Message): + imblgcaadfl: int = betterproto.uint32_field(5) + cur_fund: int = betterproto.uint32_field(2) + modfabddnkl: int = betterproto.uint32_field(7) + bdjcgcdjoeo: int = betterproto.uint32_field(1) + + +@dataclass +class MuseumTargetStartNotify(betterproto.Message): + pngddnajcgg: int = betterproto.uint32_field(2) + + +@dataclass +class MuseumTargetMissionFinishNotify(betterproto.Message): + beleodaiinb: List[int] = betterproto.uint32_field(2) + fpbgadbmead: bool = betterproto.bool_field(11) + pngddnajcgg: int = betterproto.uint32_field(5) + + +@dataclass +class MuseumTargetRewardNotify(betterproto.Message): + item_id: int = betterproto.uint32_field(5) + pngddnajcgg: int = betterproto.uint32_field(4) + item_count: int = betterproto.uint32_field(3) + + +@dataclass +class MuseumTakeCollectRewardCsReq(betterproto.Message): + item_id: int = betterproto.uint32_field(10) + + +@dataclass +class MuseumTakeCollectRewardScRsp(betterproto.Message): + item_id: int = betterproto.uint32_field(10) + retcode: int = betterproto.uint32_field(11) + reward: "ItemList" = betterproto.message_field(4) + + +@dataclass +class MusicRhythmLevel(betterproto.Message): + full_combo: bool = betterproto.bool_field(5) + level_id: int = betterproto.uint32_field(12) + unlock_level: int = betterproto.uint32_field(1) + + +@dataclass +class MusicRhythmGroup(betterproto.Message): + dnkjdjjbcdk: List[int] = betterproto.uint32_field(1) + music_group_id: int = betterproto.uint32_field(6) + music_group_phase: int = betterproto.uint32_field(12) + nbboabglcjc: List[int] = betterproto.uint32_field(5) + + +@dataclass +class MusicRhythmDataCsReq(betterproto.Message): + player_data: int = betterproto.uint32_field(12) + + +@dataclass +class MusicRhythmDataScRsp(betterproto.Message): + unlock_track_list: List[int] = betterproto.uint32_field(13) + cur_level_id: int = betterproto.uint32_field(5) + music_level: List["MusicRhythmLevel"] = betterproto.message_field(1) + unlock_song_list: List[int] = betterproto.uint32_field(2) + show_hint: bool = betterproto.bool_field(9) + cur_song_id: int = betterproto.uint32_field(10) + unlock_phase_list: List[int] = betterproto.uint32_field(7) + music_group: List["MusicRhythmGroup"] = betterproto.message_field(14) + retcode: int = betterproto.uint32_field(8) + + +@dataclass +class MusicRhythmStartLevelCsReq(betterproto.Message): + level_id: int = betterproto.uint32_field(3) + + +@dataclass +class MusicRhythmStartLevelScRsp(betterproto.Message): + mdlndgijnml: str = betterproto.string_field(15) + level_id: int = betterproto.uint32_field(10) + retcode: int = betterproto.uint32_field(4) + + +@dataclass +class MusicRhythmFinishLevelCsReq(betterproto.Message): + score_id: int = betterproto.uint32_field(1) + full_combo: bool = betterproto.bool_field(12) + mhkhaclnbpm: int = betterproto.uint32_field(11) + + +@dataclass +class MusicRhythmFinishLevelScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(4) + level_id: int = betterproto.uint32_field(9) + + +@dataclass +class MusicRhythmUnlockTrackScNotify(betterproto.Message): + jikjhneacjb: List[int] = betterproto.uint32_field(8) + + +@dataclass +class MusicRhythmSaveSongConfigDataCsReq(betterproto.Message): + cgedaboaboh: "MusicRhythmGroup" = betterproto.message_field(15) + + +@dataclass +class MusicRhythmSaveSongConfigDataScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(2) + mbldfhldcpi: int = betterproto.uint32_field(4) + cur_song_id: int = betterproto.uint32_field(3) + + +@dataclass +class MusicRhythmUnlockSongNotify(betterproto.Message): + oafhaopejpo: List[int] = betterproto.uint32_field(6) + + +@dataclass +class MusicRhythmMaxDifficultyLevelsUnlockNotify(betterproto.Message): + pass + + +@dataclass +class MusicRhythmUnlockSongSfxScNotify(betterproto.Message): + oafhaopejpo: List[int] = betterproto.uint32_field(15) + + +@dataclass +class OfferingInfo(betterproto.Message): + total_exp: int = betterproto.uint32_field(1) + offering_state: "OfferingState" = betterproto.enum_field(4) + offering_level: int = betterproto.uint32_field(11) + level_exp: int = betterproto.uint32_field(10) + has_taken_reward_id_list: List[int] = betterproto.uint32_field(7) + offering_id: int = betterproto.uint32_field(2) + + +@dataclass +class GetOfferingInfoCsReq(betterproto.Message): + offering_id_list: List[int] = betterproto.uint32_field(14) + + +@dataclass +class GetOfferingInfoScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(14) + offering_info_list: List["OfferingInfo"] = betterproto.message_field(2) + + +@dataclass +class SubmitOfferingItemCsReq(betterproto.Message): + interacted_prop_entity_id: int = betterproto.uint32_field(12) + offering_id: int = betterproto.uint32_field(5) + + +@dataclass +class SubmitOfferingItemScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(5) + offering_info: "OfferingInfo" = betterproto.message_field(11) + + +@dataclass +class TakeOfferingRewardCsReq(betterproto.Message): + interacted_prop_entity_id: int = betterproto.uint32_field(15) + offering_id: int = betterproto.uint32_field(13) + take_reward_level_list: List[int] = betterproto.uint32_field(11) + + +@dataclass +class TakeOfferingRewardScRsp(betterproto.Message): + reward: "ItemList" = betterproto.message_field(3) + offering_info: "OfferingInfo" = betterproto.message_field(8) + retcode: int = betterproto.uint32_field(12) + + +@dataclass +class OfferingInfoScNotify(betterproto.Message): + offering_info: "OfferingInfo" = betterproto.message_field(8) + + +@dataclass +class AcceptedPamMissionExpireCsReq(betterproto.Message): + main_mission_id: int = betterproto.uint32_field(9) + + +@dataclass +class AcceptedPamMissionExpireScRsp(betterproto.Message): + main_mission_id: int = betterproto.uint32_field(5) + retcode: int = betterproto.uint32_field(12) + + +@dataclass +class SyncAcceptedPamMissionNotify(betterproto.Message): + pambjbfngpo: int = betterproto.uint64_field(10) + main_mission_id: int = betterproto.uint32_field(14) + + +@dataclass +class GetPamSkinDataCsReq(betterproto.Message): + pass + + +@dataclass +class GetPamSkinDataScRsp(betterproto.Message): + unlock_skin_list: List[int] = betterproto.uint32_field(15) + retcode: int = betterproto.uint32_field(9) + cur_skin: int = betterproto.uint32_field(4) + + +@dataclass +class SelectPamSkinCsReq(betterproto.Message): + pam_skin: int = betterproto.uint32_field(13) + + +@dataclass +class SelectPamSkinScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(9) + cur_skin: int = betterproto.uint32_field(12) + set_skin: int = betterproto.uint32_field(8) + + +@dataclass +class UnlockPamSkinScNotify(betterproto.Message): + pam_skin: int = betterproto.uint32_field(11) + + +@dataclass +class GGDEMGBOFGO(betterproto.Message): + time: int = betterproto.uint32_field(14) + kkehmbpjooc: bool = betterproto.bool_field(5) + level_id: int = betterproto.uint32_field(15) + + +@dataclass +class CEHPIACKNMO(betterproto.Message): + pass + + +@dataclass +class MEDMMLKPLNL(betterproto.Message): + kcmcmpfonko: List["GGDEMGBOFGO"] = betterproto.message_field(4) + retcode: int = betterproto.uint32_field(3) + + +@dataclass +class DGEFMLBPFMM(betterproto.Message): + time: int = betterproto.uint32_field(1) + id: int = betterproto.uint32_field(14) + lpbhomfclon: int = betterproto.uint32_field(8) + + +@dataclass +class OOFKEBPANLP(betterproto.Message): + level_id: int = betterproto.uint32_field(12) + dcfhgaajlnn: List["DGEFMLBPFMM"] = betterproto.message_field(7) + + +@dataclass +class LAAICGPFABC(betterproto.Message): + pass + + +@dataclass +class FLIGGDLDOKH(betterproto.Message): + pfengldjcmg: List["OOFKEBPANLP"] = betterproto.message_field(8) + retcode: int = betterproto.uint32_field(5) + njgpikcfjnl: "OOFKEBPANLP" = betterproto.message_field(15) + + +@dataclass +class FCMADPMOMGD(betterproto.Message): + pofmcalhooc: int = betterproto.uint32_field(5) + level_id: int = betterproto.uint32_field(1) + + +@dataclass +class GPFIOILCDDH(betterproto.Message): + retcode: int = betterproto.uint32_field(14) + level_id: int = betterproto.uint32_field(4) + pofmcalhooc: int = betterproto.uint32_field(3) + + +@dataclass +class BFPOLEGCCPJ(betterproto.Message): + cnt: int = betterproto.uint32_field(5) + type: "HCFFFEIMCMF" = betterproto.enum_field(7) + + +@dataclass +class DCKPBICNMKK(betterproto.Message): + id: int = betterproto.uint32_field(5) + cnt: int = betterproto.uint32_field(11) + + +@dataclass +class OOALAODNCPE(betterproto.Message): + dhdlndfibkc: int = betterproto.uint32_field(11) + nbnekbdillk: int = betterproto.uint32_field(14) + mmabimiejnj: int = betterproto.uint32_field(15) + apnnbdbenlc: List["DCKPBICNMKK"] = betterproto.message_field(1) + oggegaolpgn: int = betterproto.uint32_field(3) + gfdipldifhg: int = betterproto.uint32_field(9) + jehjljdkbge: int = betterproto.uint32_field(7) + nfphcjipijh: int = betterproto.uint32_field(10) + oigkboohnii: int = betterproto.uint32_field(5) + fodekcobffa: int = betterproto.uint32_field(6) + neefgjbmcll: int = betterproto.uint32_field(4) + + +@dataclass +class FJJOFEKPDDH(betterproto.Message): + adjopiaibmg: int = betterproto.uint32_field(6) + hlkdfincppm: int = betterproto.uint32_field(9) + cnjjhfpmiip: int = betterproto.uint32_field(13) + chakndokncb: int = betterproto.uint32_field(1) + + +@dataclass +class FCEFAKEBFFM(betterproto.Message): + ifenfkggiem: "OOALAODNCPE" = betterproto.message_field(11) + rank: int = betterproto.uint32_field(9) + end_reason: "POAHABDKPKJ" = betterproto.enum_field(5) + baabddjehmc: int = betterproto.uint32_field(12) + pofmcalhooc: int = betterproto.uint32_field(7) + aedbpadegfi: List["BFPOLEGCCPJ"] = betterproto.message_field(1) + level_id: int = betterproto.uint32_field(14) + time: int = betterproto.uint32_field(15) + eefcbbkkflc: int = betterproto.uint32_field(2) + hmbheigkdbk: List["FJJOFEKPDDH"] = betterproto.message_field(8) + + +@dataclass +class PIOJEPCPKAC(betterproto.Message): + end_reason: "POAHABDKPKJ" = betterproto.enum_field(10) + level_id: int = betterproto.uint32_field(11) + kkehmbpjooc: bool = betterproto.bool_field(12) + blmdkjkoioh: "GGDEMGBOFGO" = betterproto.message_field(2) + fdgmoeoajkp: bool = betterproto.bool_field(1) + retcode: int = betterproto.uint32_field(9) + time: int = betterproto.uint32_field(13) + + +@dataclass +class GetPetDataCsReq(betterproto.Message): + pass + + +@dataclass +class GetPetDataScRsp(betterproto.Message): + cur_pet_id: int = betterproto.uint32_field(10) + unlocked_pet_id: List[int] = betterproto.uint32_field(3) + retcode: int = betterproto.uint32_field(5) + + +@dataclass +class SummonPetCsReq(betterproto.Message): + summoned_pet_id: int = betterproto.uint32_field(7) + + +@dataclass +class SummonPetScRsp(betterproto.Message): + select_pet_id: int = betterproto.uint32_field(13) + retcode: int = betterproto.uint32_field(12) + cur_pet_id: int = betterproto.uint32_field(14) + + +@dataclass +class RecallPetCsReq(betterproto.Message): + summoned_pet_id: int = betterproto.uint32_field(11) + + +@dataclass +class RecallPetScRsp(betterproto.Message): + cur_pet_id: int = betterproto.uint32_field(4) + select_pet_id: int = betterproto.uint32_field(7) + retcode: int = betterproto.uint32_field(14) + + +@dataclass +class CurPetChangedScNotify(betterproto.Message): + cur_pet_id: int = betterproto.uint32_field(2) + + +@dataclass +class GetPhoneDataCsReq(betterproto.Message): + pass + + +@dataclass +class GetPhoneDataScRsp(betterproto.Message): + cur_phone_theme: int = betterproto.uint32_field(7) + owned_phone_themes: List[int] = betterproto.uint32_field(10) + retcode: int = betterproto.uint32_field(2) + cur_chat_bubble: int = betterproto.uint32_field(11) + lmocamklkpi: int = betterproto.uint32_field(4) + owned_chat_bubbles: List[int] = betterproto.uint32_field(9) + kkneegdkemd: List[int] = betterproto.uint32_field(5) + + +@dataclass +class SelectChatBubbleCsReq(betterproto.Message): + bubble_id: int = betterproto.uint32_field(1) + + +@dataclass +class SelectChatBubbleScRsp(betterproto.Message): + cur_chat_bubble: int = betterproto.uint32_field(6) + retcode: int = betterproto.uint32_field(3) + pmdcbfopchb: int = betterproto.uint32_field(8) + + +@dataclass +class UnlockChatBubbleScNotify(betterproto.Message): + bubble_id: int = betterproto.uint32_field(11) + + +@dataclass +class SelectPhoneThemeCsReq(betterproto.Message): + theme_id: int = betterproto.uint32_field(3) + + +@dataclass +class SelectPhoneThemeScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(13) + achopojlcce: int = betterproto.uint32_field(4) + cur_phone_theme: int = betterproto.uint32_field(12) + + +@dataclass +class UnlockPhoneThemeScNotify(betterproto.Message): + theme_id: int = betterproto.uint32_field(5) + + +@dataclass +class SelectPhoneCaseCsReq(betterproto.Message): + phone_case_id: int = betterproto.uint32_field(13) + + +@dataclass +class SelectPhoneCaseScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(2) + pdacjdieojg: int = betterproto.uint32_field(6) + lmocamklkpi: int = betterproto.uint32_field(3) + + +@dataclass +class UnlockPhoneCaseScNotify(betterproto.Message): + phone_case_id: int = betterproto.uint32_field(11) + + +@dataclass +class GetPlanetFesDataCsReq(betterproto.Message): + pass + + +@dataclass +class GetPlanetFesDataScRsp(betterproto.Message): + hljmhnabfmc: "AJCJCHLJBGF" = betterproto.message_field(7) + retcode: int = betterproto.uint32_field(4) + lapcheignmj: "DKEJEOEHAGM" = betterproto.message_field(6) + custom_value_list: List["KHOCCHABNMN"] = betterproto.message_field(11) + heojnaimgkc: "CLKNIBOJLGP" = betterproto.message_field(12) + fdhgikjdlgd: "KOFOLLACIGO" = betterproto.message_field(13) + ebgngdgbolh: "JNIPIAADOIP" = betterproto.message_field(3) + admjkkoiagd: "GJBFGABAAMO" = betterproto.message_field(15) + level_info: "GCAMEGPEPOL" = betterproto.message_field(1) + kjkbkegighk: "AFBAMPLGHEH" = betterproto.message_field(9) + hmffhbhalge: "MIOAEGBPOMA" = betterproto.message_field(10) + skill_info: "IACFPGOLFLM" = betterproto.message_field(14) + hbdliicpkob: "OAINKJLPCDK" = betterproto.message_field(2) + + +@dataclass +class IIKNGNHDMFI(betterproto.Message): + mcnmhbjhmme: List[int] = betterproto.uint32_field(7) + + +@dataclass +class PlanetFesSyncChangeScNotify(betterproto.Message): + leadmneimdp: List["CCNANLCODDF"] = betterproto.message_field(9) + + +@dataclass +class OIDFFLEEALL(betterproto.Message): + ihelajnmmbf: int = betterproto.uint32_field(11) + imfcimkmjpl: int = betterproto.uint32_field(8) + kejnimghoig: int = betterproto.uint32_field(4) + + +@dataclass +class CCNANLCODDF(betterproto.Message): + source: "OIDFFLEEALL" = betterproto.message_field(9) + rogue_action: "HMBANCKGBII" = betterproto.message_field(3) + + +@dataclass +class OFGBMCKNLDJ(betterproto.Message): + jcfplghkjaa: "IIKNGNHDMFI" = betterproto.message_field(8) + mfknhhnfkgi: int = betterproto.int64_field(6) + dgcflhcpjln: int = betterproto.uint32_field(5) + bjodeepgopc: "IIKNGNHDMFI" = betterproto.message_field(1) + + +@dataclass +class KOFOLLACIGO(betterproto.Message): + inllekamnpf: List["OFGBMCKNLDJ"] = betterproto.message_field(13) + + +@dataclass +class EOAEGAEFPFH(betterproto.Message): + level: int = betterproto.uint32_field(4) + mhkhaclnbpm: int = betterproto.uint32_field(6) + paehamjhndd: int = betterproto.uint32_field(9) + avatar_id: int = betterproto.uint32_field(7) + + +@dataclass +class DKEJEOEHAGM(betterproto.Message): + avatar_list: List["EOAEGAEFPFH"] = betterproto.message_field(8) + + +@dataclass +class CEODDCEIDDL(betterproto.Message): + item_id: int = betterproto.uint32_field(12) + item_count: int = betterproto.uint32_field(14) + + +@dataclass +class AJCJCHLJBGF(betterproto.Message): + item_list: List["CEODDCEIDDL"] = betterproto.message_field(9) + item_value: "IIKNGNHDMFI" = betterproto.message_field(4) + pcajncbmimm: "IIKNGNHDMFI" = betterproto.message_field(13) + + +@dataclass +class OAINKJLPCDK(betterproto.Message): + option_result_info: List["PPFCJHEKOLG"] = betterproto.message_field(12) + + +@dataclass +class PPFCJHEKOLG(betterproto.Message): + source: "OIDFFLEEALL" = betterproto.message_field(3) + unique_id: int = betterproto.uint64_field(4) + dfcfhhlbgdc: List["FIMACPHLMNO"] = betterproto.message_field(10) + config_id: int = betterproto.uint32_field(5) + + +@dataclass +class FIMACPHLMNO(betterproto.Message): + kbefcmiiiin: int = betterproto.int64_field(9) + + +@dataclass +class ADAFJFOJDEG(betterproto.Message): + bonaghbbicf: int = betterproto.uint32_field(5) + nnhpcoiikff: "IIKNGNHDMFI" = betterproto.message_field(4) + quest_id: int = betterproto.uint32_field(1) + progress: int = betterproto.uint32_field(12) + m_f_a_n_n_c_a_g_d_m_p: int = betterproto.uint32_field(3) + status: "GMFEJEFIBBI" = betterproto.enum_field(6) + + +@dataclass +class PCODFCNKHJK(betterproto.Message): + eofeldeapeo: int = betterproto.uint32_field(13) + dcnphbdddip: int = betterproto.uint32_field(11) + + +@dataclass +class CLKNIBOJLGP(betterproto.Message): + quest_list: List["ADAFJFOJDEG"] = betterproto.message_field(4) + cmhnljjodjf: "PCODFCNKHJK" = betterproto.message_field(3) + + +@dataclass +class GCAMEGPEPOL(betterproto.Message): + pjolemhlgnl: int = betterproto.uint32_field(2) + ehbjbpcnplg: "IIKNGNHDMFI" = betterproto.message_field(4) + + +@dataclass +class DHNFBGENLIG(betterproto.Message): + progress: int = betterproto.uint32_field(12) + bhpcnnfokee: int = betterproto.uint32_field(15) + + +@dataclass +class AFBAMPLGHEH(betterproto.Message): + ihbjiihbibp: List[int] = betterproto.uint32_field(2) + nckcmgcbehk: List["DHNFBGENLIG"] = betterproto.message_field(8) + + +@dataclass +class HFOCNHOJLAH(betterproto.Message): + level: int = betterproto.uint32_field(1) + skill_id: int = betterproto.uint32_field(6) + + +@dataclass +class IACFPGOLFLM(betterproto.Message): + skill_list: List["HFOCNHOJLAH"] = betterproto.message_field(9) + + +@dataclass +class GJBFGABAAMO(betterproto.Message): + eimgbknlgnf: int = betterproto.uint32_field(11) + hignfpjlfka: List[int] = betterproto.uint32_field(15) + + +@dataclass +class MIOAEGBPOMA(betterproto.Message): + fgimacchhdk: List[int] = betterproto.uint32_field(2) + epcpdocdocb: int = betterproto.int64_field(12) + fgpacihlanb: int = betterproto.uint32_field(13) + + +@dataclass +class HMBANCKGBII(betterproto.Message): + lkmlgoeeekh: "GIEDCJDLEGE" = betterproto.message_field(3) + cohnlgmifbo: "GIEDCJDLEGE" = betterproto.message_field(7) + pmlocbhiddl: "HPGAGBGJLID" = betterproto.message_field(13) + lebmnloakhc: "HPGAGBGJLID" = betterproto.message_field(12) + kbnligljenn: "OFGBMCKNLDJ" = betterproto.message_field(9) + mmfbenambne: "OFGBMCKNLDJ" = betterproto.message_field(10) + gnaidhhjebi: "EOAEGAEFPFH" = betterproto.message_field(8) + jbdhlhhfdge: "EOAEGAEFPFH" = betterproto.message_field(4) + jplplfcookd: "PPFCJHEKOLG" = betterproto.message_field(5) + mkofoocokbk: "PPFCJHEKOLG" = betterproto.message_field(1) + olmgneoahop: "PHFBDNNLINF" = betterproto.message_field(6) + gbffgphfmdp: "ADAFJFOJDEG" = betterproto.message_field(15) + dmnmifjhecl: "ADAFJFOJDEG" = betterproto.message_field(11) + imfcdmieopl: "PCODFCNKHJK" = betterproto.message_field(14) + pcllcbmhcbd: "OLBOPGJFFPM" = betterproto.message_field(2) + biedmjpaebd: "HFOCNHOJLAH" = betterproto.message_field(390) + foicfogcgia: "PGNDIBBGIJN" = betterproto.message_field(1303) + nceidlnkbbg: "DJOEEGHMCFJ" = betterproto.message_field(1145) + kmmdpejakec: "CBIKMFFDCGI" = betterproto.message_field(1384) + gpnlpneehdm: "HPCAIMKJDIJ" = betterproto.message_field(797) + cneklokhahl: "HOHDMMNDKNJ" = betterproto.message_field(1446) + dmfjdahpiid: "FHNGONEFBDE" = betterproto.message_field(198) + iloekhkejaj: "PPFCJHEKOLG" = betterproto.message_field(1683) + laegjpilnnd: "ILJJBGIFDPE" = betterproto.message_field(1978) + lcdklahgkji: "DEINADPEHKE" = betterproto.message_field(79) + bcaddfdbfna: "BKBILPDKOIL" = betterproto.message_field(1725) + liglefjmlhm: "EIKAIIDAEPP" = betterproto.message_field(958) + gbncidjnlpl: "GJIPJNGNFEJ" = betterproto.message_field(656) + + +@dataclass +class OLBOPGJFFPM(betterproto.Message): + biinncndpcg: bool = betterproto.bool_field(15) + kjkbkegighk: "DHNFBGENLIG" = betterproto.message_field(3) + + +@dataclass +class PHFBDNNLINF(betterproto.Message): + ehbjbpcnplg: "IIKNGNHDMFI" = betterproto.message_field(9) + pjolemhlgnl: int = betterproto.uint32_field(1) + + +@dataclass +class GIEDCJDLEGE(betterproto.Message): + mfnaglkdpni: "IIKNGNHDMFI" = betterproto.message_field(3) + bmalpkekbel: "IIKNGNHDMFI" = betterproto.message_field(6) + ogjofmcmfpg: "IIKNGNHDMFI" = betterproto.message_field(4) + blcabemfach: List[int] = betterproto.uint32_field(2) + + +@dataclass +class HPGAGBGJLID(betterproto.Message): + item_id: int = betterproto.uint32_field(6) + ogjofmcmfpg: int = betterproto.uint32_field(15) + bmalpkekbel: int = betterproto.uint32_field(10) + + +@dataclass +class PGNDIBBGIJN(betterproto.Message): + ecilicnolfn: int = betterproto.uint32_field(15) + gfjaghljjdn: int = betterproto.uint32_field(13) + + +@dataclass +class NPAIINEKEFB(betterproto.Message): + dmaimcppjgh: "IIKNGNHDMFI" = betterproto.message_field(7) + pefdlajlcjb: int = betterproto.uint32_field(2) + avatar_id: int = betterproto.uint32_field(4) + jlceefbljdc: int = betterproto.uint32_field(6) + + +@dataclass +class ILJJBGIFDPE(betterproto.Message): + nijmjbmcfjf: int = betterproto.uint32_field(9) + pehingjkgcb: "IIKNGNHDMFI" = betterproto.message_field(11) + ccigdjcgamd: int = betterproto.uint32_field(7) + eajpdpcdjpk: "IIKNGNHDMFI" = betterproto.message_field(15) + nlaompdenkk: int = betterproto.uint32_field(3) + fofhieiicpb: "IIKNGNHDMFI" = betterproto.message_field(12) + bjelclbgalf: Dict[int, int] = betterproto.map_field( + 2, betterproto.TYPE_UINT32, betterproto.TYPE_UINT32 + ) + hdkafnkhala: int = betterproto.uint32_field(13) + membicnifli: int = betterproto.uint32_field(1) + oebafbigmbc: List["NPAIINEKEFB"] = betterproto.message_field(5) + + +@dataclass +class DJOEEGHMCFJ(betterproto.Message): + aakdahhigif: "EGBKGEMFODN" = betterproto.message_field(13) + + +@dataclass +class HPCAIMKJDIJ(betterproto.Message): + jilaggdmall: "ILMELFJCCMD" = betterproto.message_field(2) + + +@dataclass +class CBIKMFFDCGI(betterproto.Message): + hhjocipobcf: "IIKNGNHDMFI" = betterproto.message_field(1) + + +@dataclass +class HOHDMMNDKNJ(betterproto.Message): + podgjpekeeg: "DFHEJCIJBEJ" = betterproto.enum_field(5) + nfjlfnbpppg: "JOFGDAIADBO" = betterproto.message_field(8) + + +@dataclass +class FHNGONEFBDE(betterproto.Message): + eimgbknlgnf: int = betterproto.uint32_field(2) + + +@dataclass +class OHDHPCLIJNH(betterproto.Message): + eafomflmojj: int = betterproto.uint32_field(11) + iacphgojhmb: int = betterproto.uint32_field(14) + cioaogdkfog: int = betterproto.uint32_field(7) + ginmoibglnm: int = betterproto.uint32_field(12) + kjbkngcfbbp: "IIKNGNHDMFI" = betterproto.message_field(3) + + +@dataclass +class DJIAEMANGCG(betterproto.Message): + transfer_item_list: List["OHDHPCLIJNH"] = betterproto.message_field(3) + item_list: List["CEODDCEIDDL"] = betterproto.message_field(13) + + +@dataclass +class BFAAEFCEJPA(betterproto.Message): + pkbbhjpaeki: "OHDHPCLIJNH" = betterproto.message_field(14) + hocnlijhjjk: "CEODDCEIDDL" = betterproto.message_field(5) + + +@dataclass +class PlanetFesCollectIncomeCsReq(betterproto.Message): + dgcflhcpjln: int = betterproto.uint32_field(8) + + +@dataclass +class PlanetFesCollectIncomeScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(11) + + +@dataclass +class PFBFIMJFEGI(betterproto.Message): + avatar_id: int = betterproto.uint32_field(11) + dgcflhcpjln: int = betterproto.uint32_field(4) + + +@dataclass +class PlanetFesSetAvatarWorkCsReq(betterproto.Message): + kngpofhnfaj: List["PFBFIMJFEGI"] = betterproto.message_field(4) + + +@dataclass +class PlanetFesSetAvatarWorkScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(1) + + +@dataclass +class PlanetFesBuyLandCsReq(betterproto.Message): + dgcflhcpjln: int = betterproto.uint32_field(13) + + +@dataclass +class PlanetFesBuyLandScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(4) + + +@dataclass +class PlanetFesClientStatusCsReq(betterproto.Message): + fjinnlfcboj: bool = betterproto.bool_field(15) + + +@dataclass +class PlanetFesClientStatusScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(1) + + +@dataclass +class PlanetFesCollectAllIncomeCsReq(betterproto.Message): + pass + + +@dataclass +class PlanetFesCollectAllIncomeScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(8) + gndcammiloi: "IIKNGNHDMFI" = betterproto.message_field(5) + + +@dataclass +class PlanetFesDoGachaCsReq(betterproto.Message): + gacha_count: int = betterproto.uint32_field(7) + gacha_id: int = betterproto.uint32_field(6) + simulate_magic: int = betterproto.uint32_field(13) + + +@dataclass +class NEIHLDGEBHE(betterproto.Message): + avatar_id: int = betterproto.uint32_field(8) + jkjncnclfld: int = betterproto.uint32_field(12) + lpdeopgelle: "BFAAEFCEJPA" = betterproto.message_field(4) + fljpkfjajfp: int = betterproto.uint32_field(15) + + +@dataclass +class CGOJKBOEOFO(betterproto.Message): + dhhaphnmedf: List["NEIHLDGEBHE"] = betterproto.message_field(9) + jcdjcanehjd: List[int] = betterproto.uint32_field(13) + gmofklbfapl: List["BFAAEFCEJPA"] = betterproto.message_field(6) + cabcgkngaoc: "IIKNGNHDMFI" = betterproto.message_field(15) + + +@dataclass +class PJCAKIFOOCP(betterproto.Message): + jfmahmofjpi: "DJIAEMANGCG" = betterproto.message_field(15) + ecdambiifci: List[int] = betterproto.uint32_field(5) + + +@dataclass +class PlanetFesDoGachaScRsp(betterproto.Message): + idgklmcepbo: "CGOJKBOEOFO" = betterproto.message_field(12) + jabdcpfpoke: "PJCAKIFOOCP" = betterproto.message_field(11) + retcode: int = betterproto.uint32_field(9) + gacha_id: int = betterproto.uint32_field(6) + c_i_k_e_p_d_a_n_g_f_d: List["CEODDCEIDDL"] = betterproto.message_field(10) + + +@dataclass +class PlanetFesAvatarLevelUpCsReq(betterproto.Message): + ldnjeacfbje: int = betterproto.uint32_field(15) + avatar_id: int = betterproto.uint32_field(14) + + +@dataclass +class PlanetFesAvatarLevelUpScRsp(betterproto.Message): + avatar_id: int = betterproto.uint32_field(13) + ldnjeacfbje: int = betterproto.uint32_field(11) + retcode: int = betterproto.uint32_field(9) + reward: "PlanetFesReward" = betterproto.message_field(10) + bhpfpejbkec: int = betterproto.uint32_field(6) + + +@dataclass +class PlanetFesTakeQuestRewardCsReq(betterproto.Message): + quest_id: int = betterproto.uint32_field(9) + + +@dataclass +class PlanetFesTakeQuestRewardScRsp(betterproto.Message): + dnffkabfoef: "DJIAEMANGCG" = betterproto.message_field(9) + retcode: int = betterproto.uint32_field(12) + quest_id: int = betterproto.uint32_field(5) + + +@dataclass +class PlanetFesUpgradeSkillLevelCsReq(betterproto.Message): + ldnjeacfbje: int = betterproto.uint32_field(2) + skill_id: int = betterproto.uint32_field(13) + + +@dataclass +class PlanetFesUpgradeSkillLevelScRsp(betterproto.Message): + skill_level: int = betterproto.uint32_field(11) + item_cost: "CEODDCEIDDL" = betterproto.message_field(14) + retcode: int = betterproto.uint32_field(1) + skill_id: int = betterproto.uint32_field(15) + + +@dataclass +class PlanetFesReward(betterproto.Message): + coin: "IIKNGNHDMFI" = betterproto.message_field(3) + buff_map: Dict[int, int] = betterproto.map_field( + 12, betterproto.TYPE_UINT32, betterproto.TYPE_UINT32 + ) + item_list: List["CEODDCEIDDL"] = betterproto.message_field(6) + + +@dataclass +class KNOKILFKOHI(betterproto.Message): + aopikhkkglm: int = betterproto.uint32_field(12) + joooeafokhk: int = betterproto.uint32_field(15) + avatar_id: int = betterproto.uint32_field(11) + + +@dataclass +class DLLJMIAGHDD(betterproto.Message): + fjhgckenopf: List["KNOKILFKOHI"] = betterproto.message_field(5) + + +@dataclass +class EFHABDOFKDE(betterproto.Message): + agmgppaomka: Dict[int, int] = betterproto.map_field( + 4, betterproto.TYPE_UINT32, betterproto.TYPE_UINT32 + ) + epmoohcjnho: int = betterproto.uint32_field(12) + nngopakjicc: int = betterproto.uint32_field(3) + bpcfoeghonc: int = betterproto.uint32_field(1) + + +@dataclass +class CGOMNLBLJGH(betterproto.Message): + oohnkojhdho: int = betterproto.uint32_field(15) + afgkfifjfcl: int = betterproto.uint32_field(12) + rogue_current_info: "HLDHEMLPJNG" = betterproto.message_field(14) + + +@dataclass +class POHNIIFLCGE(betterproto.Message): + dgddjnhlggj: int = betterproto.uint32_field(13) + + +@dataclass +class BKODHAEECJH(betterproto.Message): + dgddjnhlggj: int = betterproto.uint32_field(9) + cgdgpgjlknm: int = betterproto.uint32_field(13) + hddijnadfdd: int = betterproto.uint32_field(12) + + +@dataclass +class CBOEMEJIFFE(betterproto.Message): + dgddjnhlggj: int = betterproto.uint32_field(5) + + +@dataclass +class JOFGDAIADBO(betterproto.Message): + pgmblloobma: "DLLJMIAGHDD" = betterproto.message_field(1) + gildjpkdpnn: "EFHABDOFKDE" = betterproto.message_field(15) + bolaiplefpi: "CGOMNLBLJGH" = betterproto.message_field(2) + genpkdaeihc: "POHNIIFLCGE" = betterproto.message_field(11) + jfnhpiegmmm: "BKODHAEECJH" = betterproto.message_field(9) + jlefnhikfoc: "CBOEMEJIFFE" = betterproto.message_field(10) + c_h_n_l_i_o_k_g_l_b_p: bool = betterproto.bool_field(14) + h_o_i_o_k_b_k_g_f_d_n: int = betterproto.uint32_field(6) + f_o_m_j_l_f_j_c_k_d_b: bool = betterproto.bool_field(7) + p_k_l_c_n_h_i_c_g_i_a: bool = betterproto.bool_field(5) + b_k_m_a_m_g_a_p_e_g_h: int = betterproto.uint32_field(13) + l_j_h_e_o_c_h_h_c_a_b: int = betterproto.int64_field(12) + d_a_j_j_j_f_c_h_o_o_j: int = betterproto.uint32_field(4) + + +@dataclass +class ILMELFJCCMD(betterproto.Message): + bkmamgapegh: int = betterproto.uint32_field(14) + coifhfpegph: int = betterproto.int64_field(3) + kmndebcffad: List["JOFGDAIADBO"] = betterproto.message_field(9) + pehingjkgcb: "IIKNGNHDMFI" = betterproto.message_field(12) + biinncndpcg: bool = betterproto.bool_field(1) + dkhigcipekf: bool = betterproto.bool_field(8) + hijddfbedpo: Dict[int, int] = betterproto.map_field( + 15, betterproto.TYPE_UINT32, betterproto.TYPE_UINT32 + ) + + +@dataclass +class FLNIDKIGGBK(betterproto.Message): + bkmamgapegh: int = betterproto.uint32_field(9) + dkhigcipekf: bool = betterproto.bool_field(14) + gjpanocngbm: int = betterproto.uint32_field(15) + pehingjkgcb: "IIKNGNHDMFI" = betterproto.message_field(11) + oebafbigmbc: List["NPAIINEKEFB"] = betterproto.message_field(12) + kneinmnlcdi: "IIKNGNHDMFI" = betterproto.message_field(4) + + +@dataclass +class LEAAHDPAIEG(betterproto.Message): + agmambdehlk: bool = betterproto.bool_field(14) + hoiokbkgfdn: int = betterproto.uint32_field(12) + + +@dataclass +class EGBKGEMFODN(betterproto.Message): + dppimjndndf: List["FLNIDKIGGBK"] = betterproto.message_field(9) + nfioacfhjnk: List["LEAAHDPAIEG"] = betterproto.message_field(1) + hjnoiengedl: int = betterproto.uint32_field(14) + ccbbdgfffag: List[int] = betterproto.uint32_field(3) + blmnekfpagh: int = betterproto.uint32_field(6) + ncikkfenhjf: "ILMELFJCCMD" = betterproto.message_field(5) + + +@dataclass +class PlanetFesGetBusinessDayInfoCsReq(betterproto.Message): + mkbpdpafapk: bool = betterproto.bool_field(14) + + +@dataclass +class PlanetFesGetBusinessDayInfoScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(12) + bcfbfmmenjk: int = betterproto.int64_field(15) + aakdahhigif: "EGBKGEMFODN" = betterproto.message_field(4) + + +@dataclass +class JNIPIAADOIP(betterproto.Message): + bcfbfmmenjk: int = betterproto.int64_field(7) + mlgfjgchonh: int = betterproto.uint32_field(6) + dkhigcipekf: bool = betterproto.bool_field(10) + hjnoiengedl: int = betterproto.uint32_field(2) + blmnekfpagh: int = betterproto.uint32_field(5) + biinncndpcg: bool = betterproto.bool_field(11) + + +@dataclass +class PlanetFesBusinessDayRefreshEventCsReq(betterproto.Message): + kblpjcfnhle: bool = betterproto.bool_field(11) + hoiokbkgfdn: int = betterproto.uint32_field(2) + bkmamgapegh: int = betterproto.uint32_field(7) + + +@dataclass +class PlanetFesBusinessDayRefreshEventScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(1) + nfjlfnbpppg: "JOFGDAIADBO" = betterproto.message_field(3) + + +@dataclass +class PlanetFesDeliverPamCargoCsReq(betterproto.Message): + aopikhkkglm: int = betterproto.uint32_field(4) + avatar_id: int = betterproto.uint32_field(12) + + +@dataclass +class PlanetFesDeliverPamCargoScRsp(betterproto.Message): + gcbdedabgko: "PlanetFesReward" = betterproto.message_field(6) + avatar_id: int = betterproto.uint32_field(13) + retcode: int = betterproto.uint32_field(8) + nfjlfnbpppg: "JOFGDAIADBO" = betterproto.message_field(1) + + +@dataclass +class PlanetFesChooseAvatarEventOptionCsReq(betterproto.Message): + nfcaambmmmb: int = betterproto.uint32_field(1) + + +@dataclass +class PlanetFesChooseAvatarEventOptionScRsp(betterproto.Message): + nfjlfnbpppg: "JOFGDAIADBO" = betterproto.message_field(15) + hakkgodicfi: int = betterproto.uint32_field(5) + epmoohcjnho: int = betterproto.uint32_field(12) + retcode: int = betterproto.uint32_field(6) + ojkjpkhdepe: int = betterproto.uint32_field(11) + reward: "PlanetFesReward" = betterproto.message_field(13) + + +@dataclass +class PlanetFesDealAvatarEventOptionItemCsReq(betterproto.Message): + nngopakjicc: int = betterproto.uint32_field(15) + lecdhddceia: bool = betterproto.bool_field(6) + + +@dataclass +class PlanetFesDealAvatarEventOptionItemScRsp(betterproto.Message): + lecdhddceia: bool = betterproto.bool_field(4) + nfjlfnbpppg: "JOFGDAIADBO" = betterproto.message_field(7) + hakkgodicfi: int = betterproto.uint32_field(5) + reward: "PlanetFesReward" = betterproto.message_field(2) + ojkjpkhdepe: int = betterproto.uint32_field(3) + retcode: int = betterproto.uint32_field(12) + + +@dataclass +class PlanetFesTakeRegionPhaseRewardCsReq(betterproto.Message): + ndbojandnjn: int = betterproto.uint32_field(4) + + +@dataclass +class PlanetFesTakeRegionPhaseRewardScRsp(betterproto.Message): + ndbojandnjn: int = betterproto.uint32_field(13) + reward_list: "ItemList" = betterproto.message_field(6) + retcode: int = betterproto.uint32_field(15) + + +@dataclass +class CNLMDFFEFJM(betterproto.Message): + gpaghiajicd: int = betterproto.uint32_field(13) + alhanjklboo: int = betterproto.uint32_field(8) + hfkggoepple: List[int] = betterproto.uint32_field(4) + cdlbehlammm: List[int] = betterproto.uint32_field(6) + + +@dataclass +class HLDHEMLPJNG(betterproto.Message): + ejcolgnjgdc: "CNLMDFFEFJM" = betterproto.message_field(3) + a_c_d_o_p_c_b_m_p_n_l: int = betterproto.uint32_field(1) + o_o_h_n_k_o_j_h_d_h_o: int = betterproto.uint32_field(14) + + +@dataclass +class FMNHLKNJNAH(betterproto.Message): + pkhlgkkippa: List[int] = betterproto.uint32_field(10) + + +@dataclass +class PlanetFesStartMiniGameCsReq(betterproto.Message): + oohnkojhdho: int = betterproto.uint32_field(3) + acdopcbmpnl: int = betterproto.uint32_field(11) + + +@dataclass +class PlanetFesStartMiniGameScRsp(betterproto.Message): + jfmahmofjpi: "FMNHLKNJNAH" = betterproto.message_field(12) + reward: "PlanetFesReward" = betterproto.message_field(7) + rogue_current_info: "HLDHEMLPJNG" = betterproto.message_field(9) + retcode: int = betterproto.uint32_field(2) + + +@dataclass +class PlanetFesUseItemCsReq(betterproto.Message): + diookfoccmo: int = betterproto.uint32_field(5) + item_id: int = betterproto.uint32_field(1) + + +@dataclass +class PlanetFesUseItemScRsp(betterproto.Message): + reward: "PlanetFesReward" = betterproto.message_field(9) + retcode: int = betterproto.uint32_field(12) + + +@dataclass +class PlanetFesGameBingoFlipCsReq(betterproto.Message): + hcfpofmdgkn: int = betterproto.uint32_field(10) + + +@dataclass +class PlanetFesGameBingoFlipScRsp(betterproto.Message): + nfeadmfnflk: bool = betterproto.bool_field(2) + reward: "PlanetFesReward" = betterproto.message_field(1) + retcode: int = betterproto.uint32_field(9) + hcfpofmdgkn: int = betterproto.uint32_field(7) + + +@dataclass +class PlanetFesBonusEventInteractCsReq(betterproto.Message): + apmodagohna: int = betterproto.uint32_field(2) + hoiokbkgfdn: int = betterproto.uint32_field(3) + + +@dataclass +class PlanetFesBonusEventInteractScRsp(betterproto.Message): + nfjlfnbpppg: "JOFGDAIADBO" = betterproto.message_field(12) + hoiokbkgfdn: int = betterproto.uint32_field(6) + retcode: int = betterproto.uint32_field(7) + reward: "PlanetFesReward" = betterproto.message_field(3) + + +@dataclass +class EIKAIIDAEPP(betterproto.Message): + bkmamgapegh: int = betterproto.uint32_field(1) + lnjiihhpmed: int = betterproto.uint32_field(15) + uid: int = betterproto.uint32_field(8) + hdcbejdenla: int = betterproto.uint32_field(6) + pjolemhlgnl: int = betterproto.uint32_field(5) + hhjocgomeco: "IIKNGNHDMFI" = betterproto.message_field(3) + dgjdmocbbii: int = betterproto.uint32_field(4) + + +@dataclass +class PlanetFesGetFriendRankingInfoListCsReq(betterproto.Message): + pass + + +@dataclass +class PlanetFesGetFriendRankingInfoListScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(4) + icmgegefdle: "EIKAIIDAEPP" = betterproto.message_field(5) + + +@dataclass +class PlanetFesFriendRankingInfoChangeScNotify(betterproto.Message): + cnheklkbmhh: List["EIKAIIDAEPP"] = betterproto.message_field(5) + + +@dataclass +class PlanetFesSetCustomKeyValueCsReq(betterproto.Message): + key: int = betterproto.uint32_field(12) + value: int = betterproto.uint32_field(8) + + +@dataclass +class PlanetFesSetCustomKeyValueScRsp(betterproto.Message): + key: int = betterproto.uint32_field(4) + retcode: int = betterproto.uint32_field(14) + value: int = betterproto.uint32_field(3) + + +@dataclass +class PlanetFesUpgradeFesLevelCsReq(betterproto.Message): + ldnjeacfbje: int = betterproto.uint32_field(13) + + +@dataclass +class PlanetFesUpgradeFesLevelScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(10) + + +@dataclass +class PlanetFesGetAvatarStatCsReq(betterproto.Message): + pass + + +@dataclass +class PlanetFesGetAvatarStatScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(13) + oebafbigmbc: List["NPAIINEKEFB"] = betterproto.message_field(9) + + +@dataclass +class DEINADPEHKE(betterproto.Message): + apply_time: int = betterproto.int64_field(11) + jpacobgbdbg: List[int] = betterproto.uint32_field(7) + pnakhnbdjae: int = betterproto.uint32_field(14) + ofgfhcldobg: int = betterproto.uint32_field(12) + + +@dataclass +class BKBILPDKOIL(betterproto.Message): + time: int = betterproto.int64_field(12) + lhjpkmdmnmp: int = betterproto.uint32_field(6) + cabehkoflpg: bool = betterproto.bool_field(7) + jpacobgbdbg: List[int] = betterproto.uint32_field(5) + hpjjdcjhhoa: int = betterproto.uint64_field(2) + + +@dataclass +class GJIPJNGNFEJ(betterproto.Message): + source: int = betterproto.uint32_field(11) + jpacobgbdbg: List[int] = betterproto.uint32_field(6) + time: int = betterproto.int64_field(7) + ofgfhcldobg: int = betterproto.uint32_field(12) + pnakhnbdjae: int = betterproto.uint32_field(8) + + +@dataclass +class PlanetFesGetExtraCardPieceInfoCsReq(betterproto.Message): + pass + + +@dataclass +class FFAPKCNAPID(betterproto.Message): + hlkpnecambl: int = betterproto.uint32_field(5) + gedglncpggn: List["DEINADPEHKE"] = betterproto.message_field(2) + obboccnflol: List["GJIPJNGNFEJ"] = betterproto.message_field(6) + uid: int = betterproto.uint32_field(15) + iemnjhlfgkd: List[int] = betterproto.uint32_field(3) + aiieklilmjc: int = betterproto.int64_field(11) + aoaefeibbmf: int = betterproto.uint32_field(1) + pbfhdnbgmbp: List["CEODDCEIDDL"] = betterproto.message_field(9) + + +@dataclass +class PlanetFesGetExtraCardPieceInfoScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(9) + baamhdnnkia: "FFAPKCNAPID" = betterproto.message_field(4) + + +@dataclass +class PlanetFesGetFriendCardPieceCsReq(betterproto.Message): + pass + + +@dataclass +class PlanetFesGetFriendCardPieceScRsp(betterproto.Message): + cgdandnibgj: List["FFAPKCNAPID"] = betterproto.message_field(3) + retcode: int = betterproto.uint32_field(8) + + +@dataclass +class PlanetFesChangeCardPieceApplyPermissionCsReq(betterproto.Message): + hlkpnecambl: int = betterproto.uint32_field(12) + + +@dataclass +class PlanetFesChangeCardPieceApplyPermissionScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(2) + hlkpnecambl: int = betterproto.uint32_field(12) + + +@dataclass +class PlanetFesApplyCardPieceCsReq(betterproto.Message): + jpacobgbdbg: List[int] = betterproto.uint32_field(12) + cbegnbkmhcd: int = betterproto.uint32_field(15) + + +@dataclass +class PlanetFesApplyCardPieceScRsp(betterproto.Message): + epcpdocdocb: int = betterproto.int64_field(9) + jpacobgbdbg: List[int] = betterproto.uint32_field(13) + cbegnbkmhcd: int = betterproto.uint32_field(1) + mcffpieeknn: bool = betterproto.bool_field(11) + pnakhnbdjae: int = betterproto.uint32_field(14) + retcode: int = betterproto.uint32_field(2) + + +@dataclass +class PlanetFesHandleCardPieceApplyCsReq(betterproto.Message): + dlhbcokcidp: List[int] = betterproto.uint32_field(15) + mdapcfheljl: bool = betterproto.bool_field(7) + ofgfhcldobg: int = betterproto.uint32_field(10) + pnakhnbdjae: int = betterproto.uint32_field(6) + + +@dataclass +class PlanetFesHandleCardPieceApplyScRsp(betterproto.Message): + pnakhnbdjae: int = betterproto.uint32_field(5) + retcode: int = betterproto.uint32_field(1) + mdapcfheljl: bool = betterproto.bool_field(11) + ppiolclpmpl: int = betterproto.int64_field(7) + dlhbcokcidp: List[int] = betterproto.uint32_field(2) + + +@dataclass +class PlanetFesGetOfferedCardPieceCsReq(betterproto.Message): + cabehkoflpg: bool = betterproto.bool_field(7) + hpjjdcjhhoa: int = betterproto.uint64_field(9) + + +@dataclass +class PlanetFesGetOfferedCardPieceScRsp(betterproto.Message): + dljckcmadhj: int = betterproto.int64_field(2) + retcode: int = betterproto.uint32_field(14) + onjgmghcpef: List["BKBILPDKOIL"] = betterproto.message_field(10) + cabehkoflpg: bool = betterproto.bool_field(12) + hpjjdcjhhoa: int = betterproto.uint64_field(6) + pbfhdnbgmbp: List["CEODDCEIDDL"] = betterproto.message_field(13) + + +@dataclass +class PlanetFesGiveCardPieceCsReq(betterproto.Message): + dlhbcokcidp: List[int] = betterproto.uint32_field(7) + cbegnbkmhcd: int = betterproto.uint32_field(11) + + +@dataclass +class PlanetFesGiveCardPieceScRsp(betterproto.Message): + dlhbcokcidp: List[int] = betterproto.uint32_field(3) + retcode: int = betterproto.uint32_field(15) + hpjjdcjhhoa: int = betterproto.uint64_field(7) + ppiolclpmpl: int = betterproto.int64_field(10) + cbegnbkmhcd: int = betterproto.uint32_field(11) + + +@dataclass +class PlanetFesLargeBonusInteractCsReq(betterproto.Message): + mopffbmabcd: int = betterproto.uint32_field(5) + ihcilnhklmc: int = betterproto.uint32_field(2) + ooiookgmehp: int = betterproto.uint32_field(1) + + +@dataclass +class PlanetFesLargeBonusInteractScRsp(betterproto.Message): + nfjlfnbpppg: "JOFGDAIADBO" = betterproto.message_field(11) + retcode: int = betterproto.uint32_field(2) + gmidjmmmjkp: "IIKNGNHDMFI" = betterproto.message_field(8) + ihcilnhklmc: int = betterproto.uint32_field(4) + + +@dataclass +class GPJACEJJMEB(betterproto.Message): + pass + + +@dataclass +class FFKKBBACICL(betterproto.Message): + retcode: int = betterproto.uint32_field(1) + + +@dataclass +class PlayerLoginCsReq(betterproto.Message): + client_version: str = betterproto.string_field(8) + login_random: int = betterproto.uint64_field(13) + +@dataclass +class PlayerLoginScRsp(betterproto.Message): + jlpkeobincp: bool = betterproto.bool_field(4) + pdikpeifann: str = betterproto.string_field(12) + login_random: int = betterproto.uint64_field(3) + igkbeamlnbj: bool = betterproto.bool_field(11) + nhmhabjkhog: str = betterproto.string_field(8) + cur_timezone: int = betterproto.int32_field(5) + retcode: int = betterproto.uint32_field(6) + server_timestamp_ms: int = betterproto.uint64_field(13) + stamina: int = betterproto.uint32_field(10) + basic_info: "PlayerBasicInfo" = betterproto.message_field(1) + + +@dataclass +class LMIPMHHPFHN(betterproto.Message): + pass + + +@dataclass +class PlayerGetTokenCsReq(betterproto.Message): + token: str = betterproto.string_field(14) + platform: int = betterproto.uint32_field(13) + icmfpnpijjf: int = betterproto.uint32_field(2) + haehhcpoapp: int = betterproto.uint32_field(8) + mempbkcjjfj: str = betterproto.string_field(15) + account_uid: str = betterproto.string_field(9) + fgojlpaejec: int = betterproto.uint32_field(11) + uid: int = betterproto.uint32_field(6) + + +@dataclass +class PlayerGetTokenScRsp(betterproto.Message): + black_info: "BlackInfo" = betterproto.message_field(12) + uid: int = betterproto.uint32_field(4) + secret_key_seed: int = betterproto.uint64_field(7) + msg: str = betterproto.string_field(6) + retcode: int = betterproto.uint32_field(1) + + +@dataclass +class GmTalkScNotify(betterproto.Message): + msg: str = betterproto.string_field(4) + + +@dataclass +class PlayerKickOutScNotify(betterproto.Message): + kick_type: "PlayerKickOutScNotifyKickType" = betterproto.enum_field(6) + black_info: "BlackInfo" = betterproto.message_field(1) + + +@dataclass +class GmTalkCsReq(betterproto.Message): + msg: str = betterproto.string_field(9) + + +@dataclass +class GmTalkScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(12) + bjdojlkehna: str = betterproto.string_field(1) + + +@dataclass +class GetBasicInfoCsReq(betterproto.Message): + pass + + +@dataclass +class OGFIODPILEL(betterproto.Message): + cacekelnmin: int = betterproto.uint32_field(5) + dmklnjboabo: bool = betterproto.bool_field(12) + akheilmndhj: bool = betterproto.bool_field(2) + + +@dataclass +class PlayerSettingInfo(betterproto.Message): + mmmnjchemfn: bool = betterproto.bool_field(3) + kapdimgjlnf: bool = betterproto.bool_field(10) + ilfalcdlaol: bool = betterproto.bool_field(15) + gmjanojmkce: bool = betterproto.bool_field(2) + pbkbglhhkpe: bool = betterproto.bool_field(9) + ghkcmdnkopn: "OGFIODPILEL" = betterproto.message_field(5) + nkekibnjmpa: bool = betterproto.bool_field(8) + kjncckhjfhe: bool = betterproto.bool_field(6) + aicnfaobcpi: bool = betterproto.bool_field(14) + aponeidmphl: bool = betterproto.bool_field(11) + njfmiljofok: bool = betterproto.bool_field(13) + + +@dataclass +class GetBasicInfoScRsp(betterproto.Message): + gender: int = betterproto.uint32_field(8) + gameplay_birthday: int = betterproto.uint32_field(2) + exchange_times: int = betterproto.uint32_field(13) + cur_day: int = betterproto.uint32_field(11) + next_recover_time: int = betterproto.int64_field(5) + player_setting_info: "PlayerSettingInfo" = betterproto.message_field(15) + week_cocoon_finished_count: int = betterproto.uint32_field(7) + last_set_nickname_time: int = betterproto.int64_field(12) + retcode: int = betterproto.uint32_field(3) + is_gender_set: bool = betterproto.bool_field(6) + + +@dataclass +class ExchangeStaminaCsReq(betterproto.Message): + pass + + +@dataclass +class ExchangeStaminaScRsp(betterproto.Message): + item_cost_list: List["ItemCost"] = betterproto.message_field(12) + stamina_add: int = betterproto.uint32_field(14) + retcode: int = betterproto.uint32_field(6) + exchange_times: int = betterproto.uint32_field(13) + last_recover_time: int = betterproto.int64_field(10) + + +@dataclass +class GetAuthkeyCsReq(betterproto.Message): + auth_appid: str = betterproto.string_field(15) + sign_type: int = betterproto.uint32_field(2) + authkey_ver: int = betterproto.uint32_field(8) + + +@dataclass +class GetAuthkeyScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(14) + sign_type: int = betterproto.uint32_field(2) + authkey_ver: int = betterproto.uint32_field(8) + authkey: str = betterproto.string_field(3) + auth_appid: str = betterproto.string_field(11) + + +@dataclass +class RegionStopScNotify(betterproto.Message): + stop_begin_time: int = betterproto.int64_field(6) + stop_end_time: int = betterproto.int64_field(4) + + +@dataclass +class AntiAddictScNotify(betterproto.Message): + msg: str = betterproto.string_field(7) + level: str = betterproto.string_field(2) + msg_type: int = betterproto.uint32_field(13) + + +@dataclass +class SetNicknameCsReq(betterproto.Message): + is_modify: bool = betterproto.bool_field(11) + nickname: str = betterproto.string_field(10) + + +@dataclass +class SetNicknameScRsp(betterproto.Message): + is_modify: bool = betterproto.bool_field(6) + jendkbooaip: int = betterproto.int64_field(12) + retcode: int = betterproto.uint32_field(11) + + +@dataclass +class GetLevelRewardTakenListCsReq(betterproto.Message): + pass + + +@dataclass +class GetLevelRewardTakenListScRsp(betterproto.Message): + level_reward_taken_list: List[int] = betterproto.uint32_field(4) + retcode: int = betterproto.uint32_field(15) + + +@dataclass +class GetLevelRewardCsReq(betterproto.Message): + interacted_prop_entity_id: int = betterproto.uint32_field(15) + level: int = betterproto.uint32_field(12) + + +@dataclass +class GetLevelRewardScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(5) + reward: "ItemList" = betterproto.message_field(1) + level: int = betterproto.uint32_field(8) + + +@dataclass +class SetLanguageCsReq(betterproto.Message): + fadpdibknbi: "LanguageType" = betterproto.enum_field(5) + + +@dataclass +class SetLanguageScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(6) + fadpdibknbi: "LanguageType" = betterproto.enum_field(1) + + +@dataclass +class AnnounceData(betterproto.Message): + banner_frequency: int = betterproto.uint32_field(10) + count_down_text: str = betterproto.string_field(7) + begin_time: int = betterproto.int64_field(6) + emergency_text: str = betterproto.string_field(14) + is_center_system_last_5_every_minutes: bool = betterproto.bool_field(12) + banner_text: str = betterproto.string_field(13) + config_id: int = betterproto.uint32_field(15) + center_system_frequency: int = betterproto.uint32_field(4) + end_time: int = betterproto.int64_field(8) + + +@dataclass +class ServerAnnounceNotify(betterproto.Message): + announce_data_list: List["AnnounceData"] = betterproto.message_field(15) + + +@dataclass +class GateServer(betterproto.Message): + mpnjikpkohj: str = betterproto.string_field(1332) + client_secret_key: str = betterproto.string_field(1134) + rogue_magic_h5_url: str = betterproto.string_field(1335) + ehimaoflgil: str = betterproto.string_field(383) + web_tool_url: str = betterproto.string_field(974) + ex_resource_url: str = betterproto.string_field(13) + enable_design_data_version_update: bool = betterproto.bool_field(6) + temporary_maintenance_url: str = betterproto.string_field(169) + asb_relogin_type: int = betterproto.uint32_field(8) + use_new_networking: bool = betterproto.bool_field(356) + login_white_msg: str = betterproto.string_field(1478) + enable_cdn_ipv6: int = betterproto.uint32_field(712) + rogue_tourn_build_ref_h5_url: str = betterproto.string_field(841) + personal_information_in_game_url: str = betterproto.string_field(1354) + design_data_relogin_desc: str = betterproto.string_field(761) + online_replay_download_url: str = betterproto.string_field(330) + stop_end_time: int = betterproto.int64_field(9) + custom_service_url: str = betterproto.string_field(1168) + stop_begin_time: int = betterproto.int64_field(14) + third_privacy_in_game_url: str = betterproto.string_field(1158) + official_community_url: str = betterproto.string_field(1087) + ifix_url: str = betterproto.string_field(425) + network_diagnostic: bool = betterproto.bool_field(1943) + rogue_tourn_build_ref_api_req_color_header_key: str = betterproto.string_field(35) + teenager_privacy_in_game_url: str = betterproto.string_field(276) + enable_watermark: bool = betterproto.bool_field(1363) + forbid_recharge: bool = betterproto.bool_field(1725) + retcode: int = betterproto.uint32_field(15) + enable_version_update: bool = betterproto.bool_field(4) + operation_feedback_url: str = betterproto.string_field(1761) + community_activity_url: str = betterproto.string_field(1456) + ecbfehfpofj: bool = betterproto.bool_field(438) + cdkey_recall_url: str = betterproto.string_field(1423) + rogue_tourn_notice_pic_type: int = betterproto.uint32_field(1204) + lhoofmaihpc: str = betterproto.string_field(30) + ifix_version: str = betterproto.string_field(236) + lua_url: str = betterproto.string_field(2) + privacy_in_game_url: str = betterproto.string_field(2038) + ip: str = betterproto.string_field(11) + region_name: str = betterproto.string_field(3) + rogue_tourn_notice_id: int = betterproto.uint32_field(526) + mdk_res_version: str = betterproto.string_field(705) + game_start_customer_service_url: str = betterproto.string_field(259) + enable_android_middle_package: bool = betterproto.bool_field(344) + rogue_tourn_build_ref_static_data_url_prefix: str = betterproto.string_field(499) + event_tracking_open: bool = betterproto.bool_field(923) + player_return_questionnaire_a_url: str = betterproto.string_field(283) + asset_bundle_url: str = betterproto.string_field(5) + oaohiecdgcc: List[str] = betterproto.string_field(373) + close_redeem_code: bool = betterproto.bool_field(609) + use_tcp: bool = betterproto.bool_field(565) + port: int = betterproto.uint32_field(1) + pooolgfkkjl: str = betterproto.string_field(905) + ipv6_address: str = betterproto.string_field(1874) + enable_upload_battle_log: bool = betterproto.bool_field(2023) + player_return_questionnaire_b_url: str = betterproto.string_field(2036) + cloud_game_url: str = betterproto.string_field(1598) + ckiofjnkemn: str = betterproto.string_field(1515) + mtp_switch: bool = betterproto.bool_field(1885) + design_data_relogin_type: int = betterproto.uint32_field(12) + pre_download_url: str = betterproto.string_field(47) + msg: str = betterproto.string_field(7) + asb_relogin_desc: str = betterproto.string_field(10) + enable_save_replay_file: bool = betterproto.bool_field(307) + denlmlcjlpg: str = betterproto.string_field(1991) + server_description: str = betterproto.string_field(108) + hot_point_url: str = betterproto.string_field(1630) + user_agreement_url: str = betterproto.string_field(805) + online_replay_upload_url: str = betterproto.string_field(1861) + player_return_invite_h5_url: str = betterproto.string_field(1685) + modibfhpmcp: bool = betterproto.bool_field(1118) + rogue_tourn_build_ref_api_req_color_header_value: str = betterproto.string_field( + 1074 + ) + ios_exam: bool = betterproto.bool_field(1144) + ngcimholjba: str = betterproto.string_field(574) + + +@dataclass +class GateServerScNotify(betterproto.Message): + connpkcchje: str = betterproto.string_field(1) + + +@dataclass +class MultiPathAvatarInfo(betterproto.Message): + dressed_skin_id: int = betterproto.uint32_field(1) + avatar_id: "MultiPathAvatarType" = betterproto.enum_field(7) + multi_path_skill_tree: List["AvatarSkillTree"] = betterproto.message_field(12) + equip_relic_list: List["EquipRelic"] = betterproto.message_field(2) + rank: int = betterproto.uint32_field(15) + path_equipment_id: int = betterproto.uint32_field(11) + + +@dataclass +class SetAvatarPathCsReq(betterproto.Message): + avatar_id: "MultiPathAvatarType" = betterproto.enum_field(11) + + +@dataclass +class SetAvatarPathScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(5) + avatar_id: "MultiPathAvatarType" = betterproto.enum_field(14) + + +@dataclass +class SetMultipleAvatarPathsCsReq(betterproto.Message): + avatar_id_list: List["MultiPathAvatarType"] = betterproto.enum_field(1) + + +@dataclass +class SetMultipleAvatarPathsScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(3) + + +@dataclass +class GetMultiPathAvatarInfoCsReq(betterproto.Message): + pass + + +@dataclass +class GetMultiPathAvatarInfoScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(14) + multi_path_avatar_info_list: List["MultiPathAvatarInfo"] = ( + betterproto.message_field(13) + ) + cur_avatar_path: Dict[int, "MultiPathAvatarType"] = betterproto.map_field( + 15, betterproto.TYPE_UINT32, betterproto.TYPE_ENUM + ) + basic_type_id_list: List[int] = betterproto.uint32_field(2) + + +@dataclass +class UnlockAvatarPathCsReq(betterproto.Message): + avatar_id: "MultiPathAvatarType" = betterproto.enum_field(11) + + +@dataclass +class UnlockAvatarPathScRsp(betterproto.Message): + reward: "ItemList" = betterproto.message_field(4) + avatar_id: "MultiPathAvatarType" = betterproto.enum_field(7) + retcode: int = betterproto.uint32_field(11) + basic_type_id_list: List[int] = betterproto.uint32_field(1) + + +@dataclass +class AvatarPathChangedNotify(betterproto.Message): + cur_multi_path_avatar_type: "MultiPathAvatarType" = betterproto.enum_field(5) + base_avatar_id: int = betterproto.uint32_field(1) + + +@dataclass +class SetGenderCsReq(betterproto.Message): + gender: "Gender" = betterproto.enum_field(2) + + +@dataclass +class SetGenderScRsp(betterproto.Message): + cur_avatar_path_info_list: List["MultiPathAvatarInfo"] = betterproto.message_field( + 6 + ) + cur_avatar_path: "MultiPathAvatarType" = betterproto.enum_field(11) + retcode: int = betterproto.uint32_field(15) + + +@dataclass +class SetPlayerInfoCsReq(betterproto.Message): + is_modify: bool = betterproto.bool_field(7) + nickname: str = betterproto.string_field(1) + gender: "Gender" = betterproto.enum_field(11) + + +@dataclass +class SetPlayerInfoScRsp(betterproto.Message): + jendkbooaip: int = betterproto.int64_field(9) + retcode: int = betterproto.uint32_field(8) + is_modify: bool = betterproto.bool_field(12) + cur_avatar_path: "MultiPathAvatarType" = betterproto.enum_field(10) + cur_avatar_path_info_list: List["MultiPathAvatarInfo"] = betterproto.message_field( + 15 + ) + + +@dataclass +class QueryProductInfoCsReq(betterproto.Message): + pass + + +@dataclass +class Product(betterproto.Message): + product_id: str = betterproto.string_field(6) + gift_type: "ProductGiftType" = betterproto.enum_field(12) + ioglpebjmdb: int = betterproto.uint32_field(5) + price_tier: str = betterproto.string_field(15) + begin_time: int = betterproto.int64_field(7) + end_time: int = betterproto.int64_field(11) + double_reward: bool = betterproto.bool_field(8) + gcbobamcalk: int = betterproto.uint32_field(9) + + +@dataclass +class QueryProductInfoScRsp(betterproto.Message): + month_card_out_date_time: int = betterproto.uint64_field(1) + odnfiaahkci: int = betterproto.uint32_field(12) + product_list: List["Product"] = betterproto.message_field(15) + retcode: int = betterproto.uint32_field(11) + cmghdmpeako: int = betterproto.uint32_field(6) + + +@dataclass +class MonthCardRewardNotify(betterproto.Message): + reward: "ItemList" = betterproto.message_field(8) + + +@dataclass +class ClientDownloadDataScNotify(betterproto.Message): + download_data: "ClientDownloadData" = betterproto.message_field(9) + + +@dataclass +class ClientObjDownloadDataScNotify(betterproto.Message): + data: "ClientObjDownloadData" = betterproto.message_field(15) + + +@dataclass +class UpdateFeatureSwitchScNotify(betterproto.Message): + switch_info_list: List["FeatureSwitchInfo"] = betterproto.message_field(7) + + +@dataclass +class DailyRefreshNotify(betterproto.Message): + gmfebdafdpj: int = betterproto.uint32_field(7) + + +@dataclass +class SetGameplayBirthdayCsReq(betterproto.Message): + birthday: int = betterproto.uint32_field(5) + + +@dataclass +class SetGameplayBirthdayScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(8) + birthday: int = betterproto.uint32_field(9) + + +@dataclass +class AceAntiCheaterCsReq(betterproto.Message): + glnkkfaipob: int = betterproto.uint32_field(14) + dgdlniefcpf: str = betterproto.string_field(3) + + +@dataclass +class AceAntiCheaterScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(15) + + +@dataclass +class RetcodeNotify(betterproto.Message): + retcode: int = betterproto.uint32_field(5) + jojppodomah: List[int] = betterproto.uint32_field(11) + + +@dataclass +class PlayerHeartBeatCsReq(betterproto.Message): + jbpemofnedg: int = betterproto.uint32_field(3) + client_time_ms: int = betterproto.uint64_field(11) + lkjmjgdebee: "ClientUploadData" = betterproto.message_field(14) + + +@dataclass +class PlayerHeartBeatScRsp(betterproto.Message): + client_time_ms: int = betterproto.uint64_field(2) + retcode: int = betterproto.uint32_field(10) + download_data: "ClientDownloadData" = betterproto.message_field(13) + server_time_ms: int = betterproto.uint64_field(8) + + +@dataclass +class FeatureSwitchClosedScNotify(betterproto.Message): + kimnkfpfbdg: "FeatureSwitchType" = betterproto.enum_field(4) + + +@dataclass +class SecretKeyInfo(betterproto.Message): + secret_key: str = betterproto.string_field(14) + type: "SecretKeyType" = betterproto.enum_field(5) + + +@dataclass +class GetSecretKeyInfoCsReq(betterproto.Message): + secret_req: bytes = betterproto.bytes_field(14) + + +@dataclass +class GetSecretKeyInfoScRsp(betterproto.Message): + secret_rsp: bytes = betterproto.bytes_field(3) + retcode: int = betterproto.uint32_field(10) + secret_info: List["SecretKeyInfo"] = betterproto.message_field(12) + + +@dataclass +class PlayerLoginFinishCsReq(betterproto.Message): + pass + + +@dataclass +class PlayerLoginFinishScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(11) + + +@dataclass +class VideoKeyInfo(betterproto.Message): + id: int = betterproto.uint32_field(6) + video_key: int = betterproto.uint64_field(8) + + +@dataclass +class GetVideoVersionKeyCsReq(betterproto.Message): + pass + + +@dataclass +class GetVideoVersionKeyScRsp(betterproto.Message): + activity_video_key_info_list: List["VideoKeyInfo"] = betterproto.message_field(3) + video_key_info_list: List["VideoKeyInfo"] = betterproto.message_field(7) + retcode: int = betterproto.uint32_field(15) + + +@dataclass +class NHJGHOKBDPK(betterproto.Message): + iipdefcedmc: int = betterproto.uint32_field(8) + nciadbakmae: int = betterproto.uint32_field(14) + jdakkofdgep: int = betterproto.uint32_field(4) + content_id: int = betterproto.uint32_field(9) + + +@dataclass +class SetRedPointStatusScNotify(betterproto.Message): + jdakkofdgep: int = betterproto.uint32_field(12) + content_id: int = betterproto.uint32_field(1) + uid: int = betterproto.uint32_field(5) + njehhffdghk: List["NHJGHOKBDPK"] = betterproto.message_field(14) + iipdefcedmc: int = betterproto.uint32_field(3) + + +@dataclass +class ReserveStaminaExchangeCsReq(betterproto.Message): + num: int = betterproto.uint32_field(11) + + +@dataclass +class ReserveStaminaExchangeScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(8) + num: int = betterproto.uint32_field(3) + + +@dataclass +class StaminaInfoScNotify(betterproto.Message): + next_recover_time: int = betterproto.int64_field(7) + reserve_stamina: int = betterproto.uint32_field(8) + stamina: int = betterproto.uint32_field(1) + dpimhemjkoe: int = betterproto.int64_field(12) + + +@dataclass +class UpdatePlayerSetting(betterproto.Message): + kapdimgjlnf: bool = betterproto.bool_field(1) + mmmnjchemfn: bool = betterproto.bool_field(8) + nkekibnjmpa: bool = betterproto.bool_field(5) + pbkbglhhkpe: bool = betterproto.bool_field(7) + njfmiljofok: bool = betterproto.bool_field(2) + aicnfaobcpi: bool = betterproto.bool_field(4) + kjncckhjfhe: bool = betterproto.bool_field(11) + aponeidmphl: bool = betterproto.bool_field(15) + gmjanojmkce: bool = betterproto.bool_field(6) + ghkcmdnkopn: "OGFIODPILEL" = betterproto.message_field(9) + ilfalcdlaol: bool = betterproto.bool_field(12) + + +@dataclass +class UpdatePlayerSettingCsReq(betterproto.Message): + player_setting: "UpdatePlayerSetting" = betterproto.message_field(13) + + +@dataclass +class UpdatePlayerSettingScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(4) + player_setting: "UpdatePlayerSetting" = betterproto.message_field(10) + + +@dataclass +class ClientObjUploadCsReq(betterproto.Message): + lkjmjgdebee: bytes = betterproto.bytes_field(15) + jbpemofnedg: int = betterproto.uint32_field(10) + + +@dataclass +class ClientObjUploadScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(10) + data: "ClientObjDownloadData" = betterproto.message_field(13) + + +@dataclass +class MENPBGGOGMC(betterproto.Message): + gkhfbfknhob: List[str] = betterproto.string_field(7) + + +@dataclass +class NCBIMLPODON(betterproto.Message): + iahopfnpfln: bool = betterproto.bool_field(1) + black_list: "MENPBGGOGMC" = betterproto.message_field(6) + + +@dataclass +class CJAKIBDIMMJ(betterproto.Message): + iahopfnpfln: bool = betterproto.bool_field(1837) + amaljfokcba: "MENPBGGOGMC" = betterproto.message_field(73) + oecbelgdlfp: "MENPBGGOGMC" = betterproto.message_field(670) + + +@dataclass +class UpdatePsnSettingsInfoCsReq(betterproto.Message): + doocplcldpd: "NCBIMLPODON" = betterproto.message_field(1512) + inhldidjgha: "CJAKIBDIMMJ" = betterproto.message_field(1533) + + +@dataclass +class UpdatePsnSettingsInfoScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(4) + + +@dataclass +class GetGameStateServiceConfigCsReq(betterproto.Message): + pass + + +@dataclass +class GetGameStateServiceConfigScRsp(betterproto.Message): + kaojcobeeon: List[str] = betterproto.string_field(12) + fibijgmkdpp: List[str] = betterproto.string_field(4) + retcode: int = betterproto.uint32_field(15) + ledkmdollbb: List[str] = betterproto.string_field(5) + + +@dataclass +class HeadIconData(betterproto.Message): + id: int = betterproto.uint32_field(5) + + +@dataclass +class DisplayAvatarData(betterproto.Message): + pos: int = betterproto.uint32_field(1) + avatar_id: int = betterproto.uint32_field(5) + + +@dataclass +class DisplayAvatarVec(betterproto.Message): + is_display: bool = betterproto.bool_field(4) + display_avatar_list: List["DisplayAvatarData"] = betterproto.message_field(15) + + +@dataclass +class GetPlayerBoardDataCsReq(betterproto.Message): + pass + + +@dataclass +class GetPlayerBoardDataScRsp(betterproto.Message): + oldmjonbjom: int = betterproto.uint32_field(10) + kknjhenmgpk: List[int] = betterproto.uint32_field(14) + current_head_icon_id: int = betterproto.uint32_field(6) + display_avatar_vec: "DisplayAvatarVec" = betterproto.message_field(2) + assist_avatar_id_list: List[int] = betterproto.uint32_field(1) + unlocked_head_icon_list: List["HeadIconData"] = betterproto.message_field(15) + signature: str = betterproto.string_field(4) + retcode: int = betterproto.uint32_field(13) + + +@dataclass +class SetHeadIconCsReq(betterproto.Message): + id: int = betterproto.uint32_field(14) + + +@dataclass +class SetHeadIconScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(5) + current_head_icon_id: int = betterproto.uint32_field(13) + + +@dataclass +class SetPersonalCardCsReq(betterproto.Message): + id: int = betterproto.uint32_field(15) + + +@dataclass +class SetPersonalCardScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(15) + oldmjonbjom: int = betterproto.uint32_field(13) + + +@dataclass +class SetDisplayAvatarCsReq(betterproto.Message): + display_avatar_list: List["DisplayAvatarData"] = betterproto.message_field(13) + + +@dataclass +class SetDisplayAvatarScRsp(betterproto.Message): + display_avatar_list: List["DisplayAvatarData"] = betterproto.message_field(8) + retcode: int = betterproto.uint32_field(2) + + +@dataclass +class SetIsDisplayAvatarInfoCsReq(betterproto.Message): + is_display: bool = betterproto.bool_field(10) + + +@dataclass +class SetIsDisplayAvatarInfoScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(9) + is_display: bool = betterproto.bool_field(2) + + +@dataclass +class SetSignatureCsReq(betterproto.Message): + signature: str = betterproto.string_field(14) + + +@dataclass +class SetSignatureScRsp(betterproto.Message): + signature: str = betterproto.string_field(6) + retcode: int = betterproto.uint32_field(8) + + +@dataclass +class SetAssistAvatarCsReq(betterproto.Message): + avatar_id_list: List[int] = betterproto.uint32_field(15) + avatar_id: int = betterproto.uint32_field(6) + + +@dataclass +class SetAssistAvatarScRsp(betterproto.Message): + avatar_id_list: List[int] = betterproto.uint32_field(15) + retcode: int = betterproto.uint32_field(10) + avatar_id: int = betterproto.uint32_field(9) + + +@dataclass +class PlayerReturnStartScNotify(betterproto.Message): + nchiekedhce: int = betterproto.uint32_field(15) + + +@dataclass +class PlayerReturnSignCsReq(betterproto.Message): + nmklegomepj: List[int] = betterproto.uint32_field(2) + opeedjihjop: int = betterproto.uint32_field(10) + + +@dataclass +class PlayerReturnSignScRsp(betterproto.Message): + opeedjihjop: int = betterproto.uint32_field(2) + nmklegomepj: List[int] = betterproto.uint32_field(6) + ipflhcjiebm: List["ItemList"] = betterproto.message_field(3) + retcode: int = betterproto.uint32_field(14) + + +@dataclass +class PlayerReturnPointChangeScNotify(betterproto.Message): + mamhojmfjof: int = betterproto.uint32_field(9) + + +@dataclass +class PlayerReturnTakePointRewardCsReq(betterproto.Message): + iifomgofmdl: int = betterproto.uint32_field(10) + cpnimljnmmf: int = betterproto.uint32_field(8) + + +@dataclass +class PlayerReturnTakePointRewardScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(12) + cpnimljnmmf: int = betterproto.uint32_field(8) + cfidbmmijhg: "ItemList" = betterproto.message_field(10) + iifomgofmdl: int = betterproto.uint32_field(2) + + +@dataclass +class PlayerReturnTakeRewardCsReq(betterproto.Message): + pass + + +@dataclass +class PlayerReturnTakeRewardScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(2) + ipflhcjiebm: "ItemList" = betterproto.message_field(11) + + +@dataclass +class PlayerReturnInfoQueryCsReq(betterproto.Message): + cehfiilmjkm: int = betterproto.uint32_field(8) + + +@dataclass +class AFBNEIBIJND(betterproto.Message): + is_taken_reward: bool = betterproto.bool_field(8) + finish_time: int = betterproto.int64_field(11) + world_level: int = betterproto.uint32_field(2) + ilcfojcdnhi: int = betterproto.uint32_field(13) + nmklegomepj: List[int] = betterproto.uint32_field(9) + status: "NOBPMMNFENJ" = betterproto.enum_field(5) + ahnfmdnejnl: int = betterproto.uint32_field(4) + mamhojmfjof: int = betterproto.uint32_field(6) + caimhcaacfg: List[int] = betterproto.uint32_field(1) + bgafghipoje: int = betterproto.uint32_field(7) + fjndpcfnflo: bool = betterproto.bool_field(12) + coifhfpegph: int = betterproto.int64_field(10) + + +@dataclass +class PlayerReturnInfoQueryScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(13) + pfeidpolokm: "AFBNEIBIJND" = betterproto.message_field(14) + gmfidnohgco: int = betterproto.uint32_field(9) + + +@dataclass +class PlayerReturnForceFinishScNotify(betterproto.Message): + pfeidpolokm: "AFBNEIBIJND" = betterproto.message_field(7) + + +@dataclass +class PlayerReturnTakeRelicCsReq(betterproto.Message): + avatar_id: int = betterproto.uint32_field(3) + + +@dataclass +class PlayerReturnTakeRelicScRsp(betterproto.Message): + avatar_id: int = betterproto.uint32_field(13) + item_list: "ItemList" = betterproto.message_field(4) + retcode: int = betterproto.uint32_field(11) + + +@dataclass +class FinishPlotCsReq(betterproto.Message): + cldajdjhoii: int = betterproto.uint32_field(7) + + +@dataclass +class FinishPlotScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(14) + cldajdjhoii: int = betterproto.uint32_field(7) + + +@dataclass +class KAOAHKAOHFI(betterproto.Message): + dhlpkmihdnm: "PunkLordBattleRecordList" = betterproto.message_field(13) + cojkeifjnek: int = betterproto.uint32_field(15) + ekkjlaokiji: "PunkLordAttackerStatus" = betterproto.enum_field(10) + basic_info: "PunkLordMonsterBasicInfo" = betterproto.message_field(7) + + +@dataclass +class GetPunkLordMonsterDataCsReq(betterproto.Message): + pass + + +@dataclass +class GetPunkLordMonsterDataScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(7) + fijnjgfabjd: List["KAOAHKAOHFI"] = betterproto.message_field(2) + + +@dataclass +class StartPunkLordRaidCsReq(betterproto.Message): + monster_id: int = betterproto.uint32_field(13) + clommfkjpmm: bool = betterproto.bool_field(4) + uid: int = betterproto.uint32_field(7) + + +@dataclass +class StartPunkLordRaidScRsp(betterproto.Message): + clommfkjpmm: bool = betterproto.bool_field(14) + dpmkammiolb: "KAOAHKAOHFI" = betterproto.message_field(8) + dmilcfhlihp: List[int] = betterproto.uint32_field(2) + scene: "FNLGPLNCPCL" = betterproto.message_field(1) + retcode: int = betterproto.uint32_field(3) + agegdmgnpdk: int = betterproto.int64_field(7) + + +@dataclass +class SharePunkLordMonsterCsReq(betterproto.Message): + monster_id: int = betterproto.uint32_field(11) + share_type: "PunkLordShareType" = betterproto.enum_field(2) + uid: int = betterproto.uint32_field(5) + + +@dataclass +class SharePunkLordMonsterScRsp(betterproto.Message): + uid: int = betterproto.uint32_field(7) + monster_id: int = betterproto.uint32_field(1) + share_type: "PunkLordShareType" = betterproto.enum_field(14) + retcode: int = betterproto.uint32_field(2) + + +@dataclass +class SummonPunkLordMonsterCsReq(betterproto.Message): + pass + + +@dataclass +class SummonPunkLordMonsterScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(8) + dpmkammiolb: "KAOAHKAOHFI" = betterproto.message_field(11) + + +@dataclass +class TakePunkLordPointRewardCsReq(betterproto.Message): + level: int = betterproto.uint32_field(11) + mdhjkkbnmcf: bool = betterproto.bool_field(10) + + +@dataclass +class TakePunkLordPointRewardScRsp(betterproto.Message): + level: int = betterproto.uint32_field(3) + reward: "ItemList" = betterproto.message_field(6) + retcode: int = betterproto.uint32_field(11) + mdhjkkbnmcf: bool = betterproto.bool_field(9) + + +@dataclass +class PunkLordMonsterInfoScNotify(betterproto.Message): + basic_info: "PunkLordMonsterBasicInfo" = betterproto.message_field(1) + dmilcfhlihp: List[int] = betterproto.uint32_field(3) + dhlpkmihdnm: "PunkLordBattleRecord" = betterproto.message_field(10) + reason: "PunkLordMonsterInfoNotifyReason" = betterproto.enum_field(13) + + +@dataclass +class GetPunkLordDataCsReq(betterproto.Message): + pass + + +@dataclass +class GetPunkLordDataScRsp(betterproto.Message): + bedjdeancoj: int = betterproto.int64_field(10) + ppnkpnbiien: int = betterproto.uint32_field(13) + bdpbdgbkdoo: int = betterproto.uint32_field(15) + retcode: int = betterproto.uint32_field(12) + gnlmkkhaekm: int = betterproto.uint32_field(11) + iadcohodgjn: int = betterproto.uint32_field(9) + gbjodjcolga: int = betterproto.uint32_field(5) + eahbikfallf: List[int] = betterproto.uint32_field(1) + + +@dataclass +class PunkLordRaidTimeOutScNotify(betterproto.Message): + dpmkammiolb: "PunkLordMonsterBasicInfo" = betterproto.message_field(2) + + +@dataclass +class PunkLordBattleResultScNotify(betterproto.Message): + ncacoccjnld: int = betterproto.uint32_field(7) + dpmkammiolb: "PunkLordMonsterBasicInfo" = betterproto.message_field(6) + pgofpnlapoe: int = betterproto.uint32_field(11) + dhlpkmihdnm: "PunkLordBattleRecord" = betterproto.message_field(5) + ahjfpngdbdo: int = betterproto.uint32_field(13) + + +@dataclass +class MDJGOOCKCMJ(betterproto.Message): + lkkjeilkpni: int = betterproto.uint32_field(1) + monster_id: int = betterproto.uint32_field(9) + config_id: int = betterproto.uint32_field(10) + ppboceckcah: bool = betterproto.bool_field(11) + world_level: int = betterproto.uint32_field(15) + create_time: int = betterproto.int64_field(4) + + +@dataclass +class GetKilledPunkLordMonsterDataCsReq(betterproto.Message): + pass + + +@dataclass +class GetKilledPunkLordMonsterDataScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(1) + ddcemdgedio: List["MDJGOOCKCMJ"] = betterproto.message_field(3) + oakkccgaekk: List["PunkLordMonsterKey"] = betterproto.message_field(15) + + +@dataclass +class PunkLordMonsterKilledNotify(betterproto.Message): + aiecobkeigb: "MDJGOOCKCMJ" = betterproto.message_field(4) + + +@dataclass +class TakeKilledPunkLordMonsterScoreCsReq(betterproto.Message): + kfejgfnonip: bool = betterproto.bool_field(10) + pkcpjjnoaln: "PunkLordMonsterKey" = betterproto.message_field(6) + + +@dataclass +class TakeKilledPunkLordMonsterScoreScRsp(betterproto.Message): + jeahdcgkbbb: List["PunkLordMonsterKey"] = betterproto.message_field(6) + retcode: int = betterproto.uint32_field(8) + kfejgfnonip: bool = betterproto.bool_field(13) + score_id: int = betterproto.uint32_field(5) + + +@dataclass +class PunkLordDataChangeNotify(betterproto.Message): + bdpbdgbkdoo: int = betterproto.uint32_field(12) + iadcohodgjn: int = betterproto.uint32_field(11) + gbjodjcolga: int = betterproto.uint32_field(7) + + +@dataclass +class GetPunkLordBattleRecordCsReq(betterproto.Message): + pkcpjjnoaln: "PunkLordMonsterKey" = betterproto.message_field(7) + + +@dataclass +class GetPunkLordBattleRecordScRsp(betterproto.Message): + battle_record_list: List["PunkLordBattleRecord"] = betterproto.message_field(10) + pkcpjjnoaln: "PunkLordMonsterKey" = betterproto.message_field(13) + retcode: int = betterproto.uint32_field(8) + okobgjhjjoa: List["PunkLordBattleReplay"] = betterproto.message_field(14) + + +@dataclass +class GetQuestDataCsReq(betterproto.Message): + pass + + +@dataclass +class Quest(betterproto.Message): + pgjngnajhpp: List[int] = betterproto.uint32_field(13) + progress: int = betterproto.uint32_field(15) + id: int = betterproto.uint32_field(7) + finish_time: int = betterproto.int64_field(4) + status: "QuestStatus" = betterproto.enum_field(2) + + +@dataclass +class GetQuestDataScRsp(betterproto.Message): + total_achievement_exp: int = betterproto.uint32_field(6) + quest_list: List["Quest"] = betterproto.message_field(4) + retcode: int = betterproto.uint32_field(1) + + +@dataclass +class TakeQuestRewardCsReq(betterproto.Message): + succ_quest_id_list: List[int] = betterproto.uint32_field(10) + + +@dataclass +class TakeQuestRewardScRsp(betterproto.Message): + reward: "ItemList" = betterproto.message_field(4) + succ_quest_id_list: List[int] = betterproto.uint32_field(3) + quest_id_list: List[int] = betterproto.uint32_field(15) + retcode: int = betterproto.uint32_field(14) + + +@dataclass +class TakeQuestOptionalRewardCsReq(betterproto.Message): + quest_id: int = betterproto.uint32_field(7) + optional_reward_id: int = betterproto.uint32_field(14) + + +@dataclass +class TakeQuestOptionalRewardScRsp(betterproto.Message): + quest_id: int = betterproto.uint32_field(2) + reward: "ItemList" = betterproto.message_field(4) + retcode: int = betterproto.uint32_field(8) + + +@dataclass +class GetQuestRecordCsReq(betterproto.Message): + pass + + +@dataclass +class EPJDFBAOFDF(betterproto.Message): + progress: int = betterproto.uint32_field(4) + ijfihgcknhg: int = betterproto.uint32_field(12) + + +@dataclass +class GetQuestRecordScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(3) + obemgacmgnh: List["EPJDFBAOFDF"] = betterproto.message_field(4) + + +@dataclass +class QuestRecordScNotify(betterproto.Message): + feaocokkgbm: "EPJDFBAOFDF" = betterproto.message_field(11) + + +@dataclass +class FinishQuestCsReq(betterproto.Message): + quest_id: int = betterproto.uint32_field(9) + prop_id: int = betterproto.uint32_field(11) + group_id: int = betterproto.uint32_field(13) + + +@dataclass +class FinishQuestScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(15) + + +@dataclass +class BatchGetQuestDataCsReq(betterproto.Message): + quest_list: List[int] = betterproto.uint32_field(15) + + +@dataclass +class BatchGetQuestDataScRsp(betterproto.Message): + quest_list: List["Quest"] = betterproto.message_field(10) + retcode: int = betterproto.uint32_field(7) + + +@dataclass +class FNLGPLNCPCL(betterproto.Message): + lineup: "LineupInfo" = betterproto.message_field(6) + world_level: int = betterproto.uint32_field(9) + raid_id: int = betterproto.uint32_field(1) + ghedlclnhij: "SceneInfo" = betterproto.message_field(13) + + +@dataclass +class StartRaidCsReq(betterproto.Message): + raid_id: int = betterproto.uint32_field(4) + is_save: int = betterproto.uint32_field(15) + world_level: int = betterproto.uint32_field(9) + avatar_list: List[int] = betterproto.uint32_field(10) + prop_entity_id: int = betterproto.uint32_field(6) + + +@dataclass +class StartRaidScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(8) + scene: "FNLGPLNCPCL" = betterproto.message_field(4) + + +@dataclass +class LeaveRaidCsReq(betterproto.Message): + raid_id: int = betterproto.uint32_field(13) + is_save: bool = betterproto.bool_field(3) + + +@dataclass +class LeaveRaidScRsp(betterproto.Message): + world_level: int = betterproto.uint32_field(5) + retcode: int = betterproto.uint32_field(15) + raid_id: int = betterproto.uint32_field(13) + + +@dataclass +class RaidTargetInfo(betterproto.Message): + dlppdpbjiim: int = betterproto.uint32_field(6) + mddofmcjjhh: "FOCHDFJANPC" = betterproto.enum_field(15) + hfaljihkecn: int = betterproto.uint32_field(2) + + +@dataclass +class RaidInfoNotify(betterproto.Message): + world_level: int = betterproto.uint32_field(9) + status: "RaidStatus" = betterproto.enum_field(14) + raid_id: int = betterproto.uint32_field(12) + raid_target_info: List["RaidTargetInfo"] = betterproto.message_field(15) + raid_finish_time: int = betterproto.uint64_field(7) + item_list: "ItemList" = betterproto.message_field(11) + + +@dataclass +class AMDKBOHCFIA(betterproto.Message): + raid_id: int = betterproto.uint32_field(1) + max_score: int = betterproto.uint32_field(15) + + +@dataclass +class FinishedRaidInfo(betterproto.Message): + world_level: int = betterproto.uint32_field(10) + raid_id: int = betterproto.uint32_field(11) + knibaniilde: List[int] = betterproto.uint32_field(4) + + +@dataclass +class GetRaidInfoCsReq(betterproto.Message): + pass + + +@dataclass +class GetRaidInfoScRsp(betterproto.Message): + finished_raid_info_list: List["FinishedRaidInfo"] = betterproto.message_field(6) + challenge_taken_reward_id_list: List[int] = betterproto.uint32_field(8) + retcode: int = betterproto.uint32_field(9) + challenge_raid_list: List["AMDKBOHCFIA"] = betterproto.message_field(4) + + +@dataclass +class GetChallengeRaidInfoCsReq(betterproto.Message): + pass + + +@dataclass +class GetChallengeRaidInfoScRsp(betterproto.Message): + mjgffcljgfn: List["AMDKBOHCFIA"] = betterproto.message_field(6) + taken_reward_id_list: List[int] = betterproto.uint32_field(13) + retcode: int = betterproto.uint32_field(2) + + +@dataclass +class TakeChallengeRaidRewardCsReq(betterproto.Message): + oehkjoafpba: int = betterproto.uint32_field(15) + + +@dataclass +class TakeChallengeRaidRewardScRsp(betterproto.Message): + oehkjoafpba: int = betterproto.uint32_field(8) + retcode: int = betterproto.uint32_field(15) + reward: "ItemList" = betterproto.message_field(12) + + +@dataclass +class ChallengeRaidNotify(betterproto.Message): + ehmiljfijkh: "AMDKBOHCFIA" = betterproto.message_field(4) + + +@dataclass +class SetClientRaidTargetCountCsReq(betterproto.Message): + dmmppkmjpmm: int = betterproto.uint32_field(12) + progress: int = betterproto.uint32_field(3) + + +@dataclass +class SetClientRaidTargetCountScRsp(betterproto.Message): + progress: int = betterproto.uint32_field(4) + retcode: int = betterproto.uint32_field(14) + dmmppkmjpmm: int = betterproto.uint32_field(6) + + +@dataclass +class GetSaveRaidCsReq(betterproto.Message): + raid_id: int = betterproto.uint32_field(12) + world_level: int = betterproto.uint32_field(1) + + +@dataclass +class GetSaveRaidScRsp(betterproto.Message): + raid_target_info: List["RaidTargetInfo"] = betterproto.message_field(5) + is_save: bool = betterproto.bool_field(4) + raid_id: int = betterproto.uint32_field(13) + retcode: int = betterproto.uint32_field(12) + world_level: int = betterproto.uint32_field(1) + + +@dataclass +class RaidData(betterproto.Message): + raid_id: int = betterproto.uint32_field(4) + world_level: int = betterproto.uint32_field(11) + raid_target_info: List["RaidTargetInfo"] = betterproto.message_field(2) + + +@dataclass +class GetAllSaveRaidCsReq(betterproto.Message): + pass + + +@dataclass +class GetAllSaveRaidScRsp(betterproto.Message): + raid_data_list: List["RaidData"] = betterproto.message_field(2) + retcode: int = betterproto.uint32_field(10) + + +@dataclass +class DelSaveRaidScNotify(betterproto.Message): + world_level: int = betterproto.uint32_field(3) + raid_id: int = betterproto.uint32_field(10) + + +@dataclass +class RaidKickByServerScNotify(betterproto.Message): + lineup: "LineupInfo" = betterproto.message_field(1) + raid_id: int = betterproto.uint32_field(12) + world_level: int = betterproto.uint32_field(6) + scene: "SceneInfo" = betterproto.message_field(2) + reason: "EGKFNDOOPNN" = betterproto.enum_field(10) + + +@dataclass +class ACONLFJEJOK(betterproto.Message): + jjdmkhbkplm: int = betterproto.uint32_field(12) + + +@dataclass +class RaidCollectionDataCsReq(betterproto.Message): + pass + + +@dataclass +class RaidCollectionDataScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(7) + challenge_list: List["ACONLFJEJOK"] = betterproto.message_field(3) + + +@dataclass +class RaidCollectionDataScNotify(betterproto.Message): + collection_info: "ACONLFJEJOK" = betterproto.message_field(14) + + +@dataclass +class RaidCollectionEnterNextRaidCsReq(betterproto.Message): + is_save: int = betterproto.uint32_field(8) + world_level: int = betterproto.uint32_field(5) + avatar_list: List[int] = betterproto.uint32_field(7) + raid_id: int = betterproto.uint32_field(9) + + +@dataclass +class RaidCollectionEnterNextRaidScRsp(betterproto.Message): + scene: "FNLGPLNCPCL" = betterproto.message_field(3) + retcode: int = betterproto.uint32_field(8) + + +@dataclass +class GetRechargeGiftInfoCsReq(betterproto.Message): + pass + + +@dataclass +class OIOPBDBJHIE(betterproto.Message): + index: int = betterproto.uint32_field(12) + status: "OIOPBDBJHIEIPKPKDCEBKI" = betterproto.enum_field(11) + + +@dataclass +class FPNJLDDAMGH(betterproto.Message): + end_time: int = betterproto.int64_field(15) + migfmpjbelg: List["OIOPBDBJHIE"] = betterproto.message_field(14) + coifhfpegph: int = betterproto.int64_field(13) + gift_type: int = betterproto.uint32_field(10) + + +@dataclass +class GetRechargeGiftInfoScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(13) + mmglcjmggih: List["FPNJLDDAMGH"] = betterproto.message_field(11) + + +@dataclass +class TakeRechargeGiftRewardCsReq(betterproto.Message): + gift_type: int = betterproto.uint32_field(14) + + +@dataclass +class TakeRechargeGiftRewardScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(7) + hnkgcndocak: "FPNJLDDAMGH" = betterproto.message_field(1) + reward: "ItemList" = betterproto.message_field(3) + + +@dataclass +class GetRechargeBenefitInfoCsReq(betterproto.Message): + pass + + +@dataclass +class JMHOJKKGNIF(betterproto.Message): + id: int = betterproto.uint32_field(4) + jclobiapkeg: List[int] = betterproto.uint32_field(14) + progress: int = betterproto.uint32_field(6) + panel_id: int = betterproto.uint32_field(8) + + +@dataclass +class GetRechargeBenefitInfoScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(15) + ehndmlffmhi: List["JMHOJKKGNIF"] = betterproto.message_field(14) + + +@dataclass +class SyncRechargeBenefitInfoScNotify(betterproto.Message): + amefppfcfji: "JMHOJKKGNIF" = betterproto.message_field(9) + + +@dataclass +class TakeRechargeBenefitRewardCsReq(betterproto.Message): + id: int = betterproto.uint32_field(7) + + +@dataclass +class TakeRechargeBenefitRewardScRsp(betterproto.Message): + reward: "ItemList" = betterproto.message_field(10) + retcode: int = betterproto.uint32_field(13) + amefppfcfji: "JMHOJKKGNIF" = betterproto.message_field(14) + + +@dataclass +class GetChallengeRecommendLineupListCsReq(betterproto.Message): + challenge_id: int = betterproto.uint32_field(10) + + +@dataclass +class ChallengeRecommendLineup(betterproto.Message): + dcholkbfbgi: int = betterproto.uint32_field(7) + first_lineup: List[int] = betterproto.uint32_field(13) + second_lineup: List[int] = betterproto.uint32_field(5) + ceifdikpdam: int = betterproto.uint32_field(3) + + +@dataclass +class GetChallengeRecommendLineupListScRsp(betterproto.Message): + challenge_recommend_list: List["ChallengeRecommendLineup"] = ( + betterproto.message_field(4) + ) + retcode: int = betterproto.uint32_field(10) + challenge_id: int = betterproto.uint32_field(9) + + +@dataclass +class EquipmentRecommendInfo(betterproto.Message): + mdmgkhlhiin: int = betterproto.uint32_field(2) + lgiiahidlmg: int = betterproto.uint32_field(13) + + +@dataclass +class EquipmentRecommend(betterproto.Message): + equipment_list: List["EquipmentRecommendInfo"] = betterproto.message_field(10) + + +@dataclass +class RelicRecommendInfo(betterproto.Message): + fikkgbibcjk: int = betterproto.uint32_field(5) + pdmgjkodfop: int = betterproto.uint32_field(13) + ehceepmbddi: int = betterproto.uint32_field(14) + + +@dataclass +class RelicRecommend(betterproto.Message): + recommend_relic_list: List["RelicRecommendInfo"] = betterproto.message_field(4) + + +@dataclass +class CAGFLKCLGCH(betterproto.Message): + dbgnciomiep: List[int] = betterproto.uint32_field(7) + + +@dataclass +class GPCPGBHOFCF(betterproto.Message): + challenge_recommend_list: List["CAGFLKCLGCH"] = betterproto.message_field(15) + + +@dataclass +class GetBigDataRecommendCsReq(betterproto.Message): + equip_avatar: int = betterproto.uint32_field(9) + big_data_recommend_type: "BigDataRecommendType" = betterproto.enum_field(4) + + +@dataclass +class GetBigDataRecommendScRsp(betterproto.Message): + equipment_recommend: "EquipmentRecommend" = betterproto.message_field( + 4 + ) + relic_recommend: "RelicRecommend" = betterproto.message_field(10) + kghlfceobkk: "GPCPGBHOFCF" = betterproto.message_field(12) + has_recommand: bool = betterproto.bool_field(8) + big_data_recommend_type: "BigDataRecommendType" = betterproto.enum_field(1) + equip_avatar: int = betterproto.uint32_field(13) + retcode: int = betterproto.uint32_field(11) + + +@dataclass +class KNNFPFKCABE(betterproto.Message): + avatar_id_list: List[int] = betterproto.uint32_field(5) + dhjhibcdnba: int = betterproto.uint32_field(14) + cfiphfhojfp: int = betterproto.uint32_field(12) + + +@dataclass +class PIIIPHEFDJO(betterproto.Message): + apfecoopnkn: List["KNNFPFKCABE"] = betterproto.message_field(12) + + +@dataclass +class NKGHHAFANHN(betterproto.Message): + kicobnpckae: int = betterproto.uint32_field(15) + iikgcjfjadf: int = betterproto.uint32_field(2) + fleefjlnlch: int = betterproto.uint32_field(7) + + +@dataclass +class GHLEDKFIIJH(betterproto.Message): + jicdflimhhd: int = betterproto.uint32_field(15) + kicobnpckae: int = betterproto.uint32_field(9) + + +@dataclass +class OFNGPLJKLOJ(betterproto.Message): + kkcmfgmhimo: List["GHLEDKFIIJH"] = betterproto.message_field(8) + fbbajbinglb: List["GHLEDKFIIJH"] = betterproto.message_field(1) + avatar_id: int = betterproto.uint32_field(7) + pdbhnhpcnnj: List["NKGHHAFANHN"] = betterproto.message_field(6) + mpmfahlkeob: List["GHLEDKFIIJH"] = betterproto.message_field(15) + nobonccpeng: List["NKGHHAFANHN"] = betterproto.message_field(12) + lgejjajpedk: List["GHLEDKFIIJH"] = betterproto.message_field(3) + + +@dataclass +class MKJALMKMPGL(betterproto.Message): + bfdmginboib: List["OFNGPLJKLOJ"] = betterproto.message_field(14) + + +@dataclass +class GetBigDataAllRecommendCsReq(betterproto.Message): + big_data_recommend_type: "BigDataRecommendType" = betterproto.enum_field(2) + + +@dataclass +class GetBigDataAllRecommendScRsp(betterproto.Message): + dklbnbdpmpo: "PIIIPHEFDJO" = betterproto.message_field(14) + pfopjpjkklk: "MKJALMKMPGL" = betterproto.message_field(13) + big_data_recommend_type: "BigDataRecommendType" = betterproto.enum_field(2) + retcode: int = betterproto.uint32_field(15) + + +@dataclass +class EJBIOKMOLAF(betterproto.Message): + ffbeebkogpn: List[int] = betterproto.uint32_field(1) + + +@dataclass +class KNCHLMGILJC(betterproto.Message): + mbgijnjfhge: Dict[int, "EJBIOKMOLAF"] = betterproto.map_field( + 13, betterproto.TYPE_UINT32, betterproto.TYPE_MESSAGE + ) + panel_id: int = betterproto.uint32_field(5) + nopdkldekkf: int = betterproto.uint32_field(9) + + +@dataclass +class GetAllRedDotDataCsReq(betterproto.Message): + pass + + +@dataclass +class GetAllRedDotDataScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(2) + iagibdaichi: List["KNCHLMGILJC"] = betterproto.message_field(11) + + +@dataclass +class UpdateRedDotDataCsReq(betterproto.Message): + panel_id: int = betterproto.uint32_field(4) + group_id: int = betterproto.uint32_field(9) + honemgcfbgi: "OJLJHFNFDKP" = betterproto.enum_field(5) + switch_list: List[int] = betterproto.uint32_field(3) + nopdkldekkf: int = betterproto.uint32_field(2) + + +@dataclass +class UpdateRedDotDataScRsp(betterproto.Message): + group_id: int = betterproto.uint32_field(12) + nopdkldekkf: int = betterproto.uint32_field(4) + retcode: int = betterproto.uint32_field(2) + panel_id: int = betterproto.uint32_field(9) + + +@dataclass +class GetSingleRedDotParamGroupCsReq(betterproto.Message): + nopdkldekkf: int = betterproto.uint32_field(6) + panel_id: int = betterproto.uint32_field(7) + group_id: int = betterproto.uint32_field(3) + + +@dataclass +class GetSingleRedDotParamGroupScRsp(betterproto.Message): + chpjjklgokm: "EJBIOKMOLAF" = betterproto.message_field(6) + nopdkldekkf: int = betterproto.uint32_field(3) + retcode: int = betterproto.uint32_field(15) + group_id: int = betterproto.uint32_field(9) + panel_id: int = betterproto.uint32_field(5) + + +@dataclass +class RelicSmartWearPlan(betterproto.Message): + inside_relic_list: List[int] = betterproto.uint32_field(7) + unique_id: int = betterproto.uint32_field(3) + avatar_id: int = betterproto.uint32_field(1) + outside_relic_list: List[int] = betterproto.uint32_field(2) + + +@dataclass +class RelicSmartWearGetPlanCsReq(betterproto.Message): + avatar_id: int = betterproto.uint32_field(7) + + +@dataclass +class RelicSmartWearGetPlanScRsp(betterproto.Message): + avatar_id: int = betterproto.uint32_field(3) + relic_plan_list: List["RelicSmartWearPlan"] = betterproto.message_field(10) + retcode: int = betterproto.uint32_field(2) + + +@dataclass +class RelicSmartWearAddPlanCsReq(betterproto.Message): + relic_plan: "RelicSmartWearPlan" = betterproto.message_field(4) + + +@dataclass +class RelicSmartWearAddPlanScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(2) + relic_plan: "RelicSmartWearPlan" = betterproto.message_field(3) + + +@dataclass +class RelicSmartWearUpdatePlanCsReq(betterproto.Message): + relic_plan: "RelicSmartWearPlan" = betterproto.message_field(15) + + +@dataclass +class RelicSmartWearUpdatePlanScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(3) + relic_plan: "RelicSmartWearPlan" = betterproto.message_field(10) + + +@dataclass +class RelicSmartWearDeletePlanCsReq(betterproto.Message): + unique_id: int = betterproto.uint32_field(4) + + +@dataclass +class RelicSmartWearDeletePlanScRsp(betterproto.Message): + unique_id: int = betterproto.uint32_field(2) + retcode: int = betterproto.uint32_field(13) + + +@dataclass +class RelicSmartWearPinRelicCsReq(betterproto.Message): + baoonjdcfkd: bool = betterproto.bool_field(9) + relic_type: int = betterproto.uint32_field(15) + avatar_id: int = betterproto.uint32_field(13) + + +@dataclass +class RelicSmartWearPinRelicScRsp(betterproto.Message): + baoonjdcfkd: bool = betterproto.bool_field(13) + retcode: int = betterproto.uint32_field(1) + avatar_id: int = betterproto.uint32_field(15) + relic_type: int = betterproto.uint32_field(2) + + +@dataclass +class RelicSmartWearGetPinRelicCsReq(betterproto.Message): + avatar_id: int = betterproto.uint32_field(9) + + +@dataclass +class RelicSmartWearGetPinRelicScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(8) + pin_relic_id_list: List[int] = betterproto.uint32_field(9) + avatar_id: int = betterproto.uint32_field(10) + + +@dataclass +class RelicSmartWearUpdatePinRelicScNotify(betterproto.Message): + avatar_id: int = betterproto.uint32_field(6) + pin_relic_id_list: List[int] = betterproto.uint32_field(7) + + +@dataclass +class GetReplayTokenCsReq(betterproto.Message): + cmpbkbbkaoa: int = betterproto.uint32_field(14) + kihbigpfkkn: str = betterproto.string_field(6) + afehlmfibmd: int = betterproto.uint32_field(3) + bbemidhmnlm: str = betterproto.string_field(13) + replay_type: "ReplayType" = betterproto.enum_field(1) + stage_id: int = betterproto.uint32_field(2) + + +@dataclass +class GetReplayTokenScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(5) + stage_id: int = betterproto.uint32_field(11) + replay_type: "ReplayType" = betterproto.enum_field(6) + token: str = betterproto.string_field(4) + kihbigpfkkn: str = betterproto.string_field(12) + + +@dataclass +class GetPlayerReplayInfoCsReq(betterproto.Message): + pass + + +@dataclass +class GetPlayerReplayInfoScRsp(betterproto.Message): + kgcfealanko: List["ReplayInfo"] = betterproto.message_field(8) + retcode: int = betterproto.uint32_field(6) + + +@dataclass +class GetRndOptionCsReq(betterproto.Message): + id: int = betterproto.uint32_field(14) + + +@dataclass +class GetRndOptionScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(14) + eegeggbdhdg: List[int] = betterproto.uint32_field(7) + + +@dataclass +class DailyFirstMeetPamCsReq(betterproto.Message): + pass + + +@dataclass +class DailyFirstMeetPamScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(14) + + +@dataclass +class RogueBuff(betterproto.Message): + buff_id: int = betterproto.uint32_field(10) + level: int = betterproto.uint32_field(5) + + +@dataclass +class RogueBuffList(betterproto.Message): + buff_list: List["RogueBuff"] = betterproto.message_field(2) + + +@dataclass +class RogueRoom(betterproto.Message): + cur_status: "RogueRoomStatus" = betterproto.enum_field(10) + imimgfaaghm: int = betterproto.uint32_field(13) + site_id: int = betterproto.uint32_field(5) + beeeboiojif: "RogueRoomStatus" = betterproto.enum_field(12) + room_id: int = betterproto.uint32_field(7) + + +@dataclass +class RogueMapInfo(betterproto.Message): + area_id: int = betterproto.uint32_field(6) + room_list: List["RogueRoom"] = betterproto.message_field(2) + cur_site_id: int = betterproto.uint32_field(9) + cur_room_id: int = betterproto.uint32_field(11) + map_id: int = betterproto.uint32_field(10) + + +@dataclass +class RogueArea(betterproto.Message): + area_id: int = betterproto.uint32_field(4) + gmpiiaeggek: int = betterproto.uint32_field(9) + mkegbhjljnh: "RogueStatus" = betterproto.enum_field(13) + area_status: "RogueAreaStatus" = betterproto.enum_field(7) + has_taken_reward: bool = betterproto.bool_field(6) + map_id: int = betterproto.uint32_field(2) + + +@dataclass +class OMOGAIEOFAH(betterproto.Message): + igchbpakbcb: int = betterproto.uint32_field(11) + pdihilclenm: List[int] = betterproto.uint32_field(9) + maze_buff_list: List["RogueBuff"] = betterproto.message_field(7) + bheidppfcka: int = betterproto.uint32_field(3) + djfckfemgoj: int = betterproto.uint32_field(1) + ipodnbljpol: int = betterproto.uint32_field(14) + can_roll: bool = betterproto.bool_field(4) + modifier_source_type: "RogueCommonBuffSelectSourceType" = betterproto.enum_field(8) + ekflpnlapdf: int = betterproto.uint32_field(6) + pdapeheambm: int = betterproto.uint32_field(13) + fpoelpfcnbi: "ItemCostData" = betterproto.message_field(10) + cmogblhafhn: int = betterproto.uint32_field(2) + ckkekmjmabc: int = betterproto.uint32_field(12) + + +@dataclass +class KFEJFBBGIAD(betterproto.Message): + kmpmdldhabn: List["RogueBuff"] = betterproto.message_field(13) + get_buff_list: "RogueBuff" = betterproto.message_field(3) + + +@dataclass +class IGJENCIKLOF(betterproto.Message): + select_hint_id: int = betterproto.uint32_field(14) + ihgmpjnnmki: List["RogueBuff"] = betterproto.message_field(10) + clplefhhafb: List["RogueBuff"] = betterproto.message_field(3) + + +@dataclass +class RogueBuffEnhanceInfo(betterproto.Message): + cost_data: "ItemCostData" = betterproto.message_field(3) + famcmagfkcl: float = betterproto.float_field(10) + buff_id: int = betterproto.uint32_field(13) + + +@dataclass +class RogueBuffEnhanceInfoList(betterproto.Message): + enhance_info_list: List["RogueBuffEnhanceInfo"] = betterproto.message_field(2) + + +@dataclass +class RogueMiracle(betterproto.Message): + durability: int = betterproto.uint32_field(4) + miracle_id: int = betterproto.uint32_field(10) + cur_times: int = betterproto.uint32_field(9) + max_times: int = betterproto.uint32_field(14) + gmafejejbho: Dict[int, int] = betterproto.map_field( + 3, betterproto.TYPE_UINT32, betterproto.TYPE_UINT32 + ) + + +@dataclass +class OLFPCKAGKAK(betterproto.Message): + miracle_list: List["RogueMiracle"] = betterproto.message_field(10) + + +@dataclass +class BFLJDBHBMNP(betterproto.Message): + game_miracle_info: "OLFPCKAGKAK" = betterproto.message_field(8) + miracle_handbook_list: List[int] = betterproto.uint32_field(10) + + +@dataclass +class KEIONFFFLCO(betterproto.Message): + cmaggnfdkag: List[int] = betterproto.uint32_field(6) + + +@dataclass +class FLECFLLDNFP(betterproto.Message): + bonus_id_list: List[int] = betterproto.uint32_field(5) + + +@dataclass +class NGFFCEICACD(betterproto.Message): + jdijkegcibp: "ItemList" = betterproto.message_field(3) + cndgjjljdof: "RogueBuffList" = betterproto.message_field(5) + e_b_n_p_o_c_i_d_p_k_e: int = betterproto.uint32_field(15) + + +@dataclass +class RogueReviveInfo(betterproto.Message): + rogue_revive_cost: "ItemCostData" = betterproto.message_field(12) + + +@dataclass +class JHEELOAGMIG(betterproto.Message): + nidflbkpoeb: int = betterproto.uint32_field(5) + + +@dataclass +class PBEKDHCLBFB(betterproto.Message): + gfdbgcolkcp: int = betterproto.uint32_field(15) + ipodnbljpol: int = betterproto.uint32_field(3) + jkjmcfagocf: int = betterproto.uint32_field(12) + hgblomelble: int = betterproto.uint32_field(7) + + +@dataclass +class RogueInfo(betterproto.Message): + rogue_current_info: "RogueCurrentInfo" = betterproto.message_field(1069) + rogue_get_info: "RogueGetInfo" = betterproto.message_field(1649) + + +@dataclass +class RogueGetInfo(betterproto.Message): + rogue_virtual_item_info: "RogueGetVirtualItemInfo" = betterproto.message_field(13) + rogue_aeon_info: "RogueAeonInfo" = betterproto.message_field(12) + rogue_score_reward_info: "RogueScoreRewardInfo" = betterproto.message_field(4) + rogue_season_info: "RogueSeasonInfo" = betterproto.message_field(8) + rogue_area_info: "RogueAreaInfo" = betterproto.message_field(7) + + +@dataclass +class RogueCurrentInfo(betterproto.Message): + rogue_lineup_info: "RogueLineupInfo" = betterproto.message_field(3) + rogue_map: "RogueMapInfo" = betterproto.message_field(4) + rogue_aeon_info: "GameAeonInfo" = betterproto.message_field(1) + game_miracle_info: "GameMiracleInfo" = betterproto.message_field(6) + status: "RogueStatus" = betterproto.enum_field(13) + is_explore_win: bool = betterproto.bool_field(10) + rogue_buff_info: "RogueBuffInfo" = betterproto.message_field(11) + virtual_item_info: "RogueVirtualItem" = betterproto.message_field(9) + pending_action: "RogueCommonPendingAction" = betterproto.message_field(15) + module_info: "RogueModuleInfo" = betterproto.message_field(5) + + +@dataclass +class RogueSeasonInfo(betterproto.Message): + begin_time: int = betterproto.int64_field(15) + end_time: int = betterproto.int64_field(3) + season: int = betterproto.uint32_field(9) + + +@dataclass +class RogueAreaInfo(betterproto.Message): + rogue_area_list: List["RogueArea"] = betterproto.message_field(5) + + +@dataclass +class RogueAeonInfo(betterproto.Message): + is_unlocked: bool = betterproto.bool_field(15) + aeon_id_list: List[int] = betterproto.uint32_field(11) + unlocked_aeon_num: int = betterproto.uint32_field(2) + unlocked_aeon_enhance_num: int = betterproto.uint32_field(3) + + +@dataclass +class RogueGetVirtualItemInfo(betterproto.Message): + bileoophjef: int = betterproto.uint32_field(9) + ifehbimemec: int = betterproto.uint32_field(4) + + +@dataclass +class RogueBuffInfo(betterproto.Message): + maze_buff_list: List["RogueBuff"] = betterproto.message_field(3) + + +@dataclass +class GameMiracleInfo(betterproto.Message): + game_miracle_info: "OLFPCKAGKAK" = betterproto.message_field(14) + + +@dataclass +class RogueLineupInfo(betterproto.Message): + mankkfpbfcb: List[int] = betterproto.uint32_field(10) + base_avatar_id_list: List[int] = betterproto.uint32_field(3) + revive_info: "RogueReviveInfo" = betterproto.message_field(8) + trial_avatar_id_list: List[int] = betterproto.uint32_field(13) + + +@dataclass +class HDJFLBMLLDP(betterproto.Message): + bonus_select_info: "FLECFLLDNFP" = betterproto.message_field(4) + + +@dataclass +class GameAeonInfo(betterproto.Message): + game_aeon_id: int = betterproto.uint32_field(12) + unlocked_aeon_enhance_num: int = betterproto.uint32_field(8) + is_unlocked: bool = betterproto.bool_field(9) + + +@dataclass +class RogueModuleInfo(betterproto.Message): + module_id_list: List[int] = betterproto.uint32_field(4) + + +@dataclass +class NIKKCCAKNNP(betterproto.Message): + game_aeon_id: int = betterproto.uint32_field(10) + unlocked_aeon_num: int = betterproto.uint32_field(2) + aeon_id_list: List[int] = betterproto.uint32_field(3) + unlocked_aeon_enhance_num: int = betterproto.uint32_field(15) + is_unlocked: bool = betterproto.bool_field(7) + + +@dataclass +class MNCDPEPCFGC(betterproto.Message): + kobfcomhgce: int = betterproto.uint32_field(6) + fjjdfpkgopc: int = betterproto.uint32_field(11) + score_id: int = betterproto.uint32_field(5) + + +@dataclass +class AOJOFBBNEPA(betterproto.Message): + dpfbdjmnceo: float = betterproto.float_field(6) + npjeecedpok: int = betterproto.uint32_field(14) + dcmhgokcinf: List["MNCDPEPCFGC"] = betterproto.message_field(5) + + +@dataclass +class FGKCAMBIAHB(betterproto.Message): + avatar_type: "AvatarType" = betterproto.enum_field(13) + slot: int = betterproto.uint32_field(11) + level: int = betterproto.uint32_field(14) + id: int = betterproto.uint32_field(8) + + +@dataclass +class GKJFBBHHLAC(betterproto.Message): + avatar_list: List["FGKCAMBIAHB"] = betterproto.message_field(10) + buff_list: List["RogueBuff"] = betterproto.message_field(14) + miracle_list: List[int] = betterproto.uint32_field(1) + + +@dataclass +class RogueFinishInfo(betterproto.Message): + ifehbimemec: int = betterproto.uint32_field(10) + bimdlghkaoi: int = betterproto.uint32_field(11) + mnbiebolccn: int = betterproto.uint32_field(13) + hlobjooebod: "ItemList" = betterproto.message_field(7) + is_win: bool = betterproto.bool_field(15) + record_info: "GKJFBBHHLAC" = betterproto.message_field(2) + agppepmgfmf: "RogueScoreRewardInfo" = betterproto.message_field(8) + area_id: int = betterproto.uint32_field(1063) + dedlgfjaeam: int = betterproto.uint32_field(9) + score_id: int = betterproto.uint32_field(1) + lmmeanjpend: int = betterproto.uint32_field(1445) + + +@dataclass +class RogueScoreRewardInfo(betterproto.Message): + pjhlocdbaeh: bool = betterproto.bool_field(2) + hoepojnnfci: int = betterproto.int64_field(14) + hdladibhbhh: int = betterproto.uint32_field(12) + cigboghafof: int = betterproto.int64_field(4) + jomnpadaggk: bool = betterproto.bool_field(8) + cilnjididhl: List[int] = betterproto.uint32_field(15) + hhjpblekapn: int = betterproto.uint32_field(3) + + +@dataclass +class EACOFHBFMLB(betterproto.Message): + exp: int = betterproto.uint32_field(3) + level: int = betterproto.uint32_field(6) + jgmipmdppij: int = betterproto.uint32_field(11) + aeon_id: int = betterproto.uint32_field(12) + + +@dataclass +class RogueDialogueEventParam(betterproto.Message): + arg_id: int = betterproto.uint32_field(14) + dialogue_event_id: int = betterproto.uint32_field(8) + is_valid: bool = betterproto.bool_field(12) + int_value: int = betterproto.int32_field(9) + ratio: float = betterproto.float_field(6) + + +@dataclass +class LANLCCOBDNE(betterproto.Message): + event_unique_id: int = betterproto.uint32_field(15) + aeon_talk_id: int = betterproto.uint32_field(14) + dialogue_event_param_list: List["RogueDialogueEventParam"] = ( + betterproto.message_field(8) + ) + game_mode_type: int = betterproto.uint32_field(7) + talk_dialogue_id: int = betterproto.uint32_field(12) + eoheeigobkd: List[int] = betterproto.uint32_field(11) + + +@dataclass +class GGHFIJKPFLN(betterproto.Message): + jdijkegcibp: "ItemList" = betterproto.message_field(13) + j_j_e_a_l_o_e_m_m_k_k: List[int] = betterproto.uint32_field(5) + b_p_l_m_p_m_e_f_e_a_m: "RogueDialogueResult" = betterproto.enum_field(15) + + +@dataclass +class GetRogueInfoCsReq(betterproto.Message): + pass + + +@dataclass +class GetRogueInfoScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(9) + rogue_game_info: "RogueInfo" = betterproto.message_field(3) + + +@dataclass +class StartRogueCsReq(betterproto.Message): + hjgndhlmmib: List[int] = betterproto.uint32_field(11) + base_avatar_id_list: List[int] = betterproto.uint32_field(6) + aeon_id: int = betterproto.uint32_field(12) + trial_avatar_id_list: List[int] = betterproto.uint32_field(8) + area_id: int = betterproto.uint32_field(15) + + +@dataclass +class StartRogueScRsp(betterproto.Message): + scene: "SceneInfo" = betterproto.message_field(8) + lineup: "LineupInfo" = betterproto.message_field(13) + rotate_info: "RogueMapRotateInfo" = betterproto.message_field(10) + rogue_game_info: "RogueInfo" = betterproto.message_field(2) + retcode: int = betterproto.uint32_field(7) + + +@dataclass +class EnterRogueCsReq(betterproto.Message): + area_id: int = betterproto.uint32_field(10) + + +@dataclass +class EnterRogueScRsp(betterproto.Message): + lineup: "LineupInfo" = betterproto.message_field(9) + retcode: int = betterproto.uint32_field(10) + rotate_info: "RogueMapRotateInfo" = betterproto.message_field(3) + rogue_game_info: "RogueInfo" = betterproto.message_field(15) + scene: "SceneInfo" = betterproto.message_field(8) + + +@dataclass +class LeaveRogueCsReq(betterproto.Message): + pass + + +@dataclass +class LeaveRogueScRsp(betterproto.Message): + scene: "SceneInfo" = betterproto.message_field(7) + retcode: int = betterproto.uint32_field(14) + rogue_game_info: "RogueInfo" = betterproto.message_field(5) + rotate_info: "RogueMapRotateInfo" = betterproto.message_field(4) + lineup: "LineupInfo" = betterproto.message_field(3) + + +@dataclass +class SyncRogueFinishScNotify(betterproto.Message): + rogue_finish_info: "RogueFinishInfo" = betterproto.message_field(1) + + +@dataclass +class PickRogueAvatarCsReq(betterproto.Message): + trial_avatar_id_list: List[int] = betterproto.uint32_field(7) + base_avatar_id_list: List[int] = betterproto.uint32_field(4) + prop_entity_id: int = betterproto.uint32_field(12) + + +@dataclass +class PickRogueAvatarScRsp(betterproto.Message): + base_avatar_id_list: List[int] = betterproto.uint32_field(6) + retcode: int = betterproto.uint32_field(5) + trial_avatar_id_list: List[int] = betterproto.uint32_field(10) + + +@dataclass +class ReviveRogueAvatarCsReq(betterproto.Message): + base_avatar_id_list: List[int] = betterproto.uint32_field(7) + interacted_prop_entity_id: int = betterproto.uint32_field(5) + trial_avatar_id_list: List[int] = betterproto.uint32_field(3) + + +@dataclass +class ReviveRogueAvatarScRsp(betterproto.Message): + trial_avatar_id_list: List[int] = betterproto.uint32_field(6) + revive_info: "RogueReviveInfo" = betterproto.message_field(12) + base_avatar_id_list: List[int] = betterproto.uint32_field(1) + retcode: int = betterproto.uint32_field(7) + + +@dataclass +class SyncRogueReviveInfoScNotify(betterproto.Message): + revive_info: "RogueReviveInfo" = betterproto.message_field(12) + + +@dataclass +class GetRogueBuffEnhanceInfoCsReq(betterproto.Message): + pass + + +@dataclass +class GetRogueBuffEnhanceInfoScRsp(betterproto.Message): + fhlomgdanjm: "RogueBuffEnhanceInfoList" = betterproto.message_field(1) + retcode: int = betterproto.uint32_field(2) + + +@dataclass +class EnhanceRogueBuffCsReq(betterproto.Message): + maze_buff_id: int = betterproto.uint32_field(10) + + +@dataclass +class EnhanceRogueBuffScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(8) + fgefcefkhmh: bool = betterproto.bool_field(2) + anagcoddmom: "RogueBuff" = betterproto.message_field(6) + + +@dataclass +class QuitRogueCsReq(betterproto.Message): + area_id: int = betterproto.uint32_field(2) + + +@dataclass +class QuitRogueScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(15) + rogue_game_info: "RogueInfo" = betterproto.message_field(1) + + +@dataclass +class SyncRogueExploreWinScNotify(betterproto.Message): + is_explore_win: bool = betterproto.bool_field(15) + + +@dataclass +class SyncRogueSeasonFinishScNotify(betterproto.Message): + nioldfffeln: bool = betterproto.bool_field(8) + rogue_score_reward_info: "RogueScoreRewardInfo" = betterproto.message_field(3) + rogue_finish_info: "RogueFinishInfo" = betterproto.message_field(11) + scene: "SceneInfo" = betterproto.message_field(4) + lineup: "LineupInfo" = betterproto.message_field(15) + + +@dataclass +class EnterRogueMapRoomCsReq(betterproto.Message): + site_id: int = betterproto.uint32_field(4) + room_id: int = betterproto.uint32_field(5) + + +@dataclass +class EnterRogueMapRoomScRsp(betterproto.Message): + scene: "SceneInfo" = betterproto.message_field(12) + rotate_info: "RogueMapRotateInfo" = betterproto.message_field(11) + cur_site_id: int = betterproto.uint32_field(10) + lineup: "LineupInfo" = betterproto.message_field(5) + retcode: int = betterproto.uint32_field(3) + + +@dataclass +class SyncRogueMapRoomScNotify(betterproto.Message): + kpekclbepgb: "RogueRoom" = betterproto.message_field(10) + map_id: int = betterproto.uint32_field(2) + + +@dataclass +class OpenRogueChestCsReq(betterproto.Message): + eiddmghlpbp: bool = betterproto.bool_field(5) + interacted_prop_entity_id: int = betterproto.uint32_field(1) + + +@dataclass +class OpenRogueChestScRsp(betterproto.Message): + drop_data: "ItemList" = betterproto.message_field(7) + reward: "ItemList" = betterproto.message_field(12) + kjchgehdlno: "MBKOCMMICPG" = betterproto.message_field(6) + retcode: int = betterproto.uint32_field(14) + + +@dataclass +class ExchangeRogueRewardKeyCsReq(betterproto.Message): + count: int = betterproto.uint32_field(14) + + +@dataclass +class ExchangeRogueRewardKeyScRsp(betterproto.Message): + count: int = betterproto.uint32_field(6) + retcode: int = betterproto.uint32_field(7) + + +@dataclass +class SyncRogueAreaUnlockScNotify(betterproto.Message): + area_id: int = betterproto.uint32_field(8) + + +@dataclass +class SyncRogueGetItemScNotify(betterproto.Message): + iodfgfomgod: "ItemList" = betterproto.message_field(14) + get_item_list: "ItemList" = betterproto.message_field(15) + + +@dataclass +class TakeRogueAeonLevelRewardCsReq(betterproto.Message): + aeon_id: int = betterproto.uint32_field(6) + level: int = betterproto.uint32_field(11) + + +@dataclass +class TakeRogueAeonLevelRewardScRsp(betterproto.Message): + aeon_id: int = betterproto.uint32_field(14) + level: int = betterproto.uint32_field(15) + reward: "ItemList" = betterproto.message_field(13) + retcode: int = betterproto.uint32_field(1) + + +@dataclass +class SyncRogueAeonLevelUpRewardScNotify(betterproto.Message): + level: int = betterproto.uint32_field(4) + reward: "ItemList" = betterproto.message_field(11) + aeon_id: int = betterproto.uint32_field(8) + + +@dataclass +class GetRogueScoreRewardInfoCsReq(betterproto.Message): + pass + + +@dataclass +class GetRogueScoreRewardInfoScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(11) + hndlhicdnpc: "RogueScoreRewardInfo" = betterproto.message_field(6) + + +@dataclass +class TakeRogueScoreRewardCsReq(betterproto.Message): + hhjpblekapn: int = betterproto.uint32_field(9) + lmmfpcokhee: List[int] = betterproto.uint32_field(8) + + +@dataclass +class TakeRogueScoreRewardScRsp(betterproto.Message): + hhjpblekapn: int = betterproto.uint32_field(2) + rogue_score_reward_info: "RogueScoreRewardInfo" = betterproto.message_field(8) + retcode: int = betterproto.uint32_field(15) + reward: "ItemList" = betterproto.message_field(13) + + +@dataclass +class GetRogueInitialScoreCsReq(betterproto.Message): + pass + + +@dataclass +class GetRogueInitialScoreScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(3) + rogue_score_reward_info: "RogueScoreRewardInfo" = betterproto.message_field(1) + + +@dataclass +class GetRogueAeonInfoCsReq(betterproto.Message): + pass + + +@dataclass +class GetRogueAeonInfoScRsp(betterproto.Message): + belofmfhfdk: List["EACOFHBFMLB"] = betterproto.message_field(4) + retcode: int = betterproto.uint32_field(10) + + +@dataclass +class FinishAeonDialogueGroupCsReq(betterproto.Message): + aeon_id: int = betterproto.uint32_field(1) + + +@dataclass +class FinishAeonDialogueGroupScRsp(betterproto.Message): + rogue_aeon_info: "EACOFHBFMLB" = betterproto.message_field(7) + retcode: int = betterproto.uint32_field(10) + reward: "ItemList" = betterproto.message_field(6) + + +@dataclass +class GetRogueTalentInfoCsReq(betterproto.Message): + pass + + +@dataclass +class GetRogueTalentInfoScRsp(betterproto.Message): + talent_info_list: "RogueTalentInfoList" = betterproto.message_field(11) + retcode: int = betterproto.uint32_field(9) + + +@dataclass +class EnableRogueTalentCsReq(betterproto.Message): + talent_id: int = betterproto.uint32_field(4) + + +@dataclass +class EnableRogueTalentScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(10) + talent_info_list: "RogueTalentInfoList" = betterproto.message_field(9) + + +@dataclass +class SyncRogueVirtualItemInfoScNotify(betterproto.Message): + rogue_virtual_item_info: "PBEKDHCLBFB" = betterproto.message_field(11) + + +@dataclass +class SyncRogueStatusScNotify(betterproto.Message): + jienhhahfgi: bool = betterproto.bool_field(1) + status: "RogueStatus" = betterproto.enum_field(5) + + +@dataclass +class SyncRogueRewardInfoScNotify(betterproto.Message): + rogue_score_reward_info: "RogueScoreRewardInfo" = betterproto.message_field(12) + + +@dataclass +class SyncRoguePickAvatarInfoScNotify(betterproto.Message): + base_avatar_id_list: List[int] = betterproto.uint32_field(12) + trial_avatar_id_list: List[int] = betterproto.uint32_field(7) + + +@dataclass +class SyncRogueAeonScNotify(betterproto.Message): + gcjogflgbbh: "NIKKCCAKNNP" = betterproto.message_field(6) + + +@dataclass +class LLPNBNEJKII(betterproto.Message): + lineup: "LineupInfo" = betterproto.message_field(3) + scene: "SceneInfo" = betterproto.message_field(2) + rotate_info: "RogueMapRotateInfo" = betterproto.message_field(7) + + +@dataclass +class RogueArcadeStartCsReq(betterproto.Message): + base_avatar_id_list: List[int] = betterproto.uint32_field(5) + room_id: int = betterproto.uint32_field(2) + + +@dataclass +class RogueArcadeStartScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(5) + room_id: int = betterproto.uint32_field(13) + rogue_tourn_cur_scene_info: "LLPNBNEJKII" = betterproto.message_field(14) + + +@dataclass +class RogueArcadeLeaveCsReq(betterproto.Message): + pass + + +@dataclass +class RogueArcadeLeaveScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(6) + rogue_tourn_cur_scene_info: "LLPNBNEJKII" = betterproto.message_field(8) + + +@dataclass +class RogueArcadeRestartCsReq(betterproto.Message): + pass + + +@dataclass +class RogueArcadeRestartScRsp(betterproto.Message): + rogue_tourn_cur_scene_info: "LLPNBNEJKII" = betterproto.message_field(15) + retcode: int = betterproto.uint32_field(3) + + +@dataclass +class RogueArcadeGetInfoCsReq(betterproto.Message): + pass + + +@dataclass +class RogueArcadeGetInfoScRsp(betterproto.Message): + room_id: int = betterproto.uint32_field(4) + retcode: int = betterproto.uint32_field(9) + + +@dataclass +class RogueCommonBuff(betterproto.Message): + buff_id: int = betterproto.uint32_field(6) + buff_level: int = betterproto.uint32_field(15) + + +@dataclass +class ChessRogueBuff(betterproto.Message): + buff_list: List["RogueCommonBuff"] = betterproto.message_field(11) + + +@dataclass +class RogueCommonBuffSelectInfo(betterproto.Message): + source_cur_count: int = betterproto.uint32_field(14) + certain_select_buff_id: int = betterproto.uint32_field(5) + roll_buff_max_count: int = betterproto.uint32_field(2) + source_total_count: int = betterproto.uint32_field(12) + can_roll: bool = betterproto.bool_field(10) + handbook_unlock_buff_id_list: List[int] = betterproto.uint32_field(6) + first_buff_type_list: List[int] = betterproto.uint32_field(1) + roll_buff_free_count: int = betterproto.uint32_field(7) + source_type: "RogueCommonBuffSelectSourceType" = betterproto.enum_field(13) + select_buff_list: List["RogueCommonBuff"] = betterproto.message_field(11) + roll_buff_cost_data: "ItemCostData" = betterproto.message_field(8) + source_hint_id: int = betterproto.uint32_field(3) + roll_buff_count: int = betterproto.uint32_field(4) + + +@dataclass +class RogueBuffSelectResult(betterproto.Message): + buff_select_id: int = betterproto.uint32_field(14) + + +@dataclass +class RogueBuffSelectCallback(betterproto.Message): + pass + + +@dataclass +class RogueBuffRerollResult(betterproto.Message): + pass + + +@dataclass +class RogueBuffRerollCallback(betterproto.Message): + buff_select_info: "RogueCommonBuffSelectInfo" = betterproto.message_field(1) + + +@dataclass +class ChessRogueBuffEnhanceInfo(betterproto.Message): + buff_id: int = betterproto.uint32_field(12) + cost_data: "ItemCostData" = betterproto.message_field(7) + + +@dataclass +class ChessRogueBuffEnhanceList(betterproto.Message): + enhance_info_list: List["ChessRogueBuffEnhanceInfo"] = betterproto.message_field(12) + + +@dataclass +class INEMPCAKNNC(betterproto.Message): + select_hint_id: int = betterproto.uint32_field(13) + ihgmpjnnmki: List["RogueCommonBuff"] = betterproto.message_field(2) + clplefhhafb: List["RogueCommonBuff"] = betterproto.message_field(10) + + +@dataclass +class LEFCOMGMPCL(betterproto.Message): + ihgmpjnnmki: List["RogueCommonBuff"] = betterproto.message_field(1) + select_hint_id: int = betterproto.uint32_field(15) + + +@dataclass +class PBMAKLNJEKO(betterproto.Message): + ljejkccbcha: int = betterproto.uint32_field(9) + + +@dataclass +class FKDBIHNPCHE(betterproto.Message): + pass + + +@dataclass +class IPGKAGFFBHF(betterproto.Message): + select_hint_id: int = betterproto.uint32_field(12) + dlfmgkpgmhl: List["RogueCommonBuff"] = betterproto.message_field(11) + + +@dataclass +class OKEFIDDNLKG(betterproto.Message): + buff_select_id: int = betterproto.uint32_field(7) + + +@dataclass +class DLHPDALGDEH(betterproto.Message): + pass + + +@dataclass +class RogueCommonBuffReforgeSelectInfo(betterproto.Message): + select_buffs: List["RogueCommonBuff"] = betterproto.message_field(2) + select_hint_id: int = betterproto.uint32_field(5) + + +@dataclass +class RogueBuffReforgeSelectResult(betterproto.Message): + buff_select_id: int = betterproto.uint32_field(6) + + +@dataclass +class RogueBuffReforgeSelectCallback(betterproto.Message): + pass + + +@dataclass +class ChessRogueBuffInfo(betterproto.Message): + chess_rogue_buff_info: "ChessRogueBuff" = betterproto.message_field(3) + + +@dataclass +class GameRogueMiracle(betterproto.Message): + cur_times: int = betterproto.uint32_field(12) + miracle_id: int = betterproto.uint32_field(14) + durability: int = betterproto.uint32_field(10) + gmafejejbho: Dict[int, int] = betterproto.map_field( + 4, betterproto.TYPE_UINT32, betterproto.TYPE_UINT32 + ) + + +@dataclass +class LAJBHGHNBAC(betterproto.Message): + ganhklnpapi: bool = betterproto.bool_field(10) + bemceedabfd: int = betterproto.uint32_field(5) + jalamopldho: "GameRogueMiracle" = betterproto.message_field(8) + + +@dataclass +class RogueCommonMiracle(betterproto.Message): + miracle_info: "GameRogueMiracle" = betterproto.message_field(8) + + +@dataclass +class RogueCommonRemoveMiracle(betterproto.Message): + miracle_id: int = betterproto.uint32_field(9) + + +@dataclass +class IBIBPOOPDEN(betterproto.Message): + fkpihaahhbi: int = betterproto.uint32_field(1) + lgjfnaiagld: int = betterproto.uint32_field(5) + miracle_info: "GameRogueMiracle" = betterproto.message_field(14) + + +@dataclass +class MAAAAGPJJFE(betterproto.Message): + miracle_info: "GameRogueMiracle" = betterproto.message_field(3) + + +@dataclass +class PBALOEJCGFN(betterproto.Message): + bemceedabfd: int = betterproto.uint32_field(12) + jalamopldho: "GameRogueMiracle" = betterproto.message_field(15) + + +@dataclass +class HBLNHGANBAB(betterproto.Message): + miracle_info: "GameRogueMiracle" = betterproto.message_field(11) + + +@dataclass +class ChessRogueMiracle(betterproto.Message): + miracle_list: List["GameRogueMiracle"] = betterproto.message_field(2) + + +@dataclass +class RogueMiracleSelectInfo(betterproto.Message): + select_hint_id: int = betterproto.uint32_field(4) + select_miracle_list: List[int] = betterproto.uint32_field(3) + apikleggdhm: bool = betterproto.bool_field(13) + miracle_handbook_list: List[int] = betterproto.uint32_field(12) + oooecpaacck: int = betterproto.uint32_field(6) + bmfcbcmclaf: int = betterproto.uint32_field(1) + + +@dataclass +class MPPHHNAEEDK(betterproto.Message): + cghlhfnladn: int = betterproto.uint32_field(1) + + +@dataclass +class CFFOCCHBAMH(betterproto.Message): + pass + + +@dataclass +class JFPFDJPPOAG(betterproto.Message): + pass + + +@dataclass +class HONKBMJPJAA(betterproto.Message): + miracle_select_info: "RogueMiracleSelectInfo" = betterproto.message_field(8) + + +@dataclass +class ANMCAIMELCA(betterproto.Message): + cmaggnfdkag: List[int] = betterproto.uint32_field(1) + + +@dataclass +class GABBEHOIPJC(betterproto.Message): + dcjeggjpcdf: List[int] = betterproto.uint32_field(1) + select_hint_id: int = betterproto.uint32_field(12) + + +@dataclass +class NALELIGHDAA(betterproto.Message): + abmamcfpcci: int = betterproto.uint32_field(1) + + +@dataclass +class PAOCONGELJK(betterproto.Message): + pass + + +@dataclass +class MLKICCAELKE(betterproto.Message): + anbpnihmkah: List[int] = betterproto.uint32_field(3) + select_hint_id: int = betterproto.uint32_field(6) + + +@dataclass +class PKODMMPHIBC(betterproto.Message): + jibhljneicm: int = betterproto.uint32_field(12) + + +@dataclass +class BLFJBKBHJIL(betterproto.Message): + pass + + +@dataclass +class EAKECFAPPKD(betterproto.Message): + select_hint_id: int = betterproto.uint32_field(14) + fikenbeondj: List[int] = betterproto.uint32_field(3) + + +@dataclass +class NHCKHPLKLIO(betterproto.Message): + ibemojgallk: int = betterproto.uint32_field(6) + + +@dataclass +class OMJFMBJMFMC(betterproto.Message): + pass + + +@dataclass +class ELDAFCNMFBF(betterproto.Message): + mdpdadooobn: List[int] = betterproto.uint32_field(2) + select_hint_id: int = betterproto.uint32_field(9) + + +@dataclass +class LHJPIKEKPGH(betterproto.Message): + gakjolgdbbd: int = betterproto.uint32_field(11) + + +@dataclass +class MOIKNHHCABH(betterproto.Message): + pass + + +@dataclass +class RogueComposeMiracleSelectInfo(betterproto.Message): + jlhfojodokg: List[int] = betterproto.uint32_field(7) + select_hint_id: int = betterproto.uint32_field(9) + + +@dataclass +class IMCBIIGOKPM(betterproto.Message): + cghlhfnladn: int = betterproto.uint32_field(10) + + +@dataclass +class FHIKPLAIOEI(betterproto.Message): + pass + + +@dataclass +class RogueHexAvatarSelectInfo(betterproto.Message): + select_hint_id: int = betterproto.uint32_field(3) + jlhfojodokg: List[int] = betterproto.uint32_field(7) + + +@dataclass +class LKMKHACMAPC(betterproto.Message): + cghlhfnladn: int = betterproto.uint32_field(2) + + +@dataclass +class NOCOCFHOAJC(betterproto.Message): + pass + + +@dataclass +class IMLBIBJKPDB(betterproto.Message): + eidnigddohp: int = betterproto.uint32_field(8) + + +@dataclass +class JCAHMIOOLDB(betterproto.Message): + pass + + +@dataclass +class ChessRogueMiracleInfo(betterproto.Message): + chess_rogue_miracle_info: "ChessRogueMiracle" = betterproto.message_field(10) + + +@dataclass +class RogueBonusSelectInfo(betterproto.Message): + bonus_id_list: List[int] = betterproto.uint32_field(13) + + +@dataclass +class RogueVirtualItem(betterproto.Message): + rogue_money: int = betterproto.uint32_field(5) + dafalaoaooi: int = betterproto.uint32_field(6) + bpjoapfafkk: int = betterproto.uint32_field(7) + amnkmbmhkdf: int = betterproto.uint32_field(14) + + +@dataclass +class RogueCommonMoney(betterproto.Message): + num: int = betterproto.uint32_field(5) + display_type: int = betterproto.uint32_field(15) + + +@dataclass +class MDGJIKLJDDE(betterproto.Message): + avatar_type: "AvatarType" = betterproto.enum_field(15) + avatar_id: int = betterproto.uint32_field(7) + + +@dataclass +class RogueSyncContextBoardEvent(betterproto.Message): + modifier_effect_type: int = betterproto.uint32_field(1) + board_event_id: int = betterproto.uint32_field(12) + + +@dataclass +class CFELLCPMONH(betterproto.Message): + item_list: "ItemList" = betterproto.message_field(11) + + +@dataclass +class OIAOLBGOAAG(betterproto.Message): + noaednnibaf: "RogueSyncContextBoardEvent" = betterproto.message_field(15) + hhphlegcldm: "CFELLCPMONH" = betterproto.message_field(4) + + +@dataclass +class RogueAdventureRoomTargetNone(betterproto.Message): + pass + + +@dataclass +class RogueAdventureRoomTargetCoin(betterproto.Message): + count: int = betterproto.int32_field(10) + + +@dataclass +class RogueAdventureRoomTargetMiracle(betterproto.Message): + miracle_id: int = betterproto.uint32_field(7) + + +@dataclass +class RogueAdventureRoomTargetRuanmei(betterproto.Message): + pass + + +@dataclass +class RogueAdventureRoomGameplayWolfGunTarget(betterproto.Message): + target_none: "RogueAdventureRoomTargetNone" = betterproto.message_field( + 8 + ) + target_coin: "RogueAdventureRoomTargetCoin" = betterproto.message_field( + 12 + ) + target_miracle: "RogueAdventureRoomTargetMiracle" = betterproto.message_field( + 14 + ) + target_ruanmei: "RogueAdventureRoomTargetRuanmei" = betterproto.message_field( + 10 + ) + + +@dataclass +class RogueAdventureRoomGameplayWolfGunGameInfo(betterproto.Message): + battle_target_list: List["RogueAdventureRoomGameplayWolfGunTarget"] = ( + betterproto.message_field(2) + ) + game_target_num: int = betterproto.uint32_field(7) + + +@dataclass +class RogueAdventureRoomGameplayWolfGunInfo(betterproto.Message): + game_info: "RogueAdventureRoomGameplayWolfGunGameInfo" = betterproto.message_field( + 5 + ) + + +@dataclass +class AdventureRoomInfo(betterproto.Message): + sus: float = betterproto.double_field(4) + score_id: int = betterproto.uint32_field(14) + status: int = betterproto.uint32_field(8) + caught_monster_num: int = betterproto.uint32_field(3) + query_info: "RogueAdventureRoomGameplayWolfGunInfo" = betterproto.message_field(13) + remain_monster_num: int = betterproto.uint32_field(2) + + +@dataclass +class SyncRogueAdventureRoomInfoScNotify(betterproto.Message): + adventure_room_info: "AdventureRoomInfo" = betterproto.message_field(11) + + +@dataclass +class PrepareRogueAdventureRoomCsReq(betterproto.Message): + pass + + +@dataclass +class PrepareRogueAdventureRoomScRsp(betterproto.Message): + adventure_room_info: "AdventureRoomInfo" = betterproto.message_field(12) + retcode: int = betterproto.uint32_field(4) + + +@dataclass +class StopRogueAdventureRoomCsReq(betterproto.Message): + mmhmdhihcab: int = betterproto.uint32_field(6) + ipogaccfmol: List[int] = betterproto.uint32_field(14) + + +@dataclass +class StopRogueAdventureRoomScRsp(betterproto.Message): + adventure_room_info: "AdventureRoomInfo" = betterproto.message_field(2) + retcode: int = betterproto.uint32_field(15) + + +@dataclass +class GetRogueAdventureRoomInfoCsReq(betterproto.Message): + pass + + +@dataclass +class GetRogueAdventureRoomInfoScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(7) + adventure_room_info: "AdventureRoomInfo" = betterproto.message_field(14) + + +@dataclass +class UpdateRogueAdventureRoomScoreCsReq(betterproto.Message): + hmffhgbkogl: int = betterproto.uint32_field(3) + score_id: int = betterproto.uint32_field(2) + + +@dataclass +class UpdateRogueAdventureRoomScoreScRsp(betterproto.Message): + adventure_room_info: "AdventureRoomInfo" = betterproto.message_field(15) + retcode: int = betterproto.uint32_field(10) + + +@dataclass +class AHCLNMJPMIJ(betterproto.Message): + miracle_id: int = betterproto.uint32_field(5) + bphcbohkhmd: bool = betterproto.bool_field(10) + poapegkpfob: bool = betterproto.bool_field(4) + cost_data: "ItemCostData" = betterproto.message_field(1) + nblffdipbhi: "ItemCostData" = betterproto.message_field(14) + + +@dataclass +class MGKFKECFHHM(betterproto.Message): + cost_data: "ItemCostData" = betterproto.message_field(11) + bphcbohkhmd: bool = betterproto.bool_field(3) + buff_id: int = betterproto.uint32_field(10) + nblffdipbhi: "ItemCostData" = betterproto.message_field(9) + poapegkpfob: bool = betterproto.bool_field(2) + leaaebafchp: int = betterproto.uint32_field(12) + + +@dataclass +class IILHOAKJDNH(betterproto.Message): + nblffdipbhi: "ItemCostData" = betterproto.message_field(7) + cost_data: "ItemCostData" = betterproto.message_field(15) + poapegkpfob: bool = betterproto.bool_field(6) + bphcbohkhmd: bool = betterproto.bool_field(5) + formula_id: int = betterproto.uint32_field(8) + + +@dataclass +class NNJOLKJLPJG(betterproto.Message): + miracle_list: List["AHCLNMJPMIJ"] = betterproto.message_field(3) + + +@dataclass +class ANJDKFJOEEI(betterproto.Message): + buff_list: List["MGKFKECFHHM"] = betterproto.message_field(9) + + +@dataclass +class GLPPDLECCLI(betterproto.Message): + game_formula_info: List["IILHOAKJDNH"] = betterproto.message_field(11) + + +@dataclass +class GetRogueShopBuffInfoCsReq(betterproto.Message): + interacted_prop_entity_id: int = betterproto.uint32_field(7) + hmilghcpede: bool = betterproto.bool_field(10) + + +@dataclass +class GetRogueShopBuffInfoScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(15) + rogue_buff_info: "ANJDKFJOEEI" = betterproto.message_field(8) + ihjhccfmifd: "ItemCostData" = betterproto.message_field(4) + aefhkanbfnc: int = betterproto.int32_field(10) + efojocfgidj: int = betterproto.int32_field(3) + + +@dataclass +class GetRogueShopMiracleInfoCsReq(betterproto.Message): + interacted_prop_entity_id: int = betterproto.uint32_field(7) + hmilghcpede: bool = betterproto.bool_field(11) + + +@dataclass +class GetRogueShopMiracleInfoScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(2) + game_miracle_info: "NNJOLKJLPJG" = betterproto.message_field(3) + efojocfgidj: int = betterproto.int32_field(4) + aefhkanbfnc: int = betterproto.int32_field(13) + ihjhccfmifd: "ItemCostData" = betterproto.message_field(12) + + +@dataclass +class GetRogueShopFormulaInfoCsReq(betterproto.Message): + interacted_prop_entity_id: int = betterproto.uint32_field(13) + hmilghcpede: bool = betterproto.bool_field(12) + + +@dataclass +class GetRogueShopFormulaInfoScRsp(betterproto.Message): + efojocfgidj: int = betterproto.int32_field(5) + aefhkanbfnc: int = betterproto.int32_field(3) + ckaanmddkcj: "GLPPDLECCLI" = betterproto.message_field(12) + retcode: int = betterproto.uint32_field(9) + ihjhccfmifd: "ItemCostData" = betterproto.message_field(7) + + +@dataclass +class AGPIFOFNCNA(betterproto.Message): + miracle_id: int = betterproto.uint32_field(9) + interacted_prop_entity_id: int = betterproto.uint32_field(8) + + +@dataclass +class MHDDHODMMIA(betterproto.Message): + buff_id_list: List[int] = betterproto.uint32_field(15) + interacted_prop_entity_id: int = betterproto.uint32_field(5) + + +@dataclass +class BuyRogueShopFormulaCsReq(betterproto.Message): + interacted_prop_entity_id: int = betterproto.uint32_field(6) + aoiihcfmfph: List[int] = betterproto.uint32_field(13) + + +@dataclass +class BuyRogueShopMiracleScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(15) + game_miracle_info: "NNJOLKJLPJG" = betterproto.message_field(6) + + +@dataclass +class BuyRogueShopBuffScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(1) + rogue_buff_info: "ANJDKFJOEEI" = betterproto.message_field(13) + + +@dataclass +class BuyRogueShopFormulaScRsp(betterproto.Message): + ckaanmddkcj: "GLPPDLECCLI" = betterproto.message_field(3) + retcode: int = betterproto.uint32_field(14) + + +@dataclass +class RogueNpcDisappearCsReq(betterproto.Message): + icinggkoemg: int = betterproto.uint32_field(8) + + +@dataclass +class RogueNpcDisappearScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(8) + + +@dataclass +class MAJNGEFBHDG(betterproto.Message): + interacted_prop_entity_id: int = betterproto.uint32_field(14) + + +@dataclass +class GFLHCFLNPBB(betterproto.Message): + nopheehjhek: "SceneBattleInfo" = betterproto.message_field(9) + retcode: int = betterproto.uint32_field(6) + + +@dataclass +class SyncRogueCommonActionResultScNotify(betterproto.Message): + action_result_list: List["RogueCommonActionResult"] = betterproto.message_field(1) + display_type: "RogueCommonActionResultDisplayType" = betterproto.enum_field(7) + rogue_sub_mode: int = betterproto.uint32_field(6) + + +@dataclass +class RogueCommonActionResult(betterproto.Message): + source: "RogueCommonActionResultSourceType" = betterproto.enum_field(11) + rogue_action: "RogueCommonActionResultData" = betterproto.message_field(5) + + +@dataclass +class FormulaBuffTypeInfo(betterproto.Message): + key: int = betterproto.uint32_field(2) + formula_buff_num: int = betterproto.int32_field(12) + + +@dataclass +class MLPKNLLAOIF(betterproto.Message): + cfclogfjpbd: int = betterproto.int32_field(11) + jpnfbfkhpgd: int = betterproto.uint32_field(15) + eegcbbhophg: int = betterproto.int32_field(9) + + +@dataclass +class FormulaInfo(betterproto.Message): + formula_id: int = betterproto.uint32_field(12) + formula_buff_type_list: List["FormulaBuffTypeInfo"] = betterproto.message_field(10) + is_expand: bool = betterproto.bool_field(9) + + +@dataclass +class FormulaTypeValue(betterproto.Message): + formula_type_map: Dict[int, int] = betterproto.map_field( + 2, betterproto.TYPE_UINT32, betterproto.TYPE_INT32 + ) + + +@dataclass +class RogueCommonFormula(betterproto.Message): + formula_info: "FormulaInfo" = betterproto.message_field(14) + + +@dataclass +class RogueCommonRemoveFormula(betterproto.Message): + formula_info: "FormulaInfo" = betterproto.message_field(15) + + +@dataclass +class RogueCommonExpandedFormula(betterproto.Message): + formula_info: "FormulaInfo" = betterproto.message_field(9) + + +@dataclass +class RogueCommonContractFormula(betterproto.Message): + formula_info: "FormulaInfo" = betterproto.message_field(4) + + +@dataclass +class FIPFPHBPHLH(betterproto.Message): + ilbkmnajgmo: List["MLPKNLLAOIF"] = betterproto.message_field(8) + + +@dataclass +class RogueCommonPathBuff(betterproto.Message): + value: "FormulaTypeValue" = betterproto.message_field(13) + + +@dataclass +class RogueTournFormulaInfo(betterproto.Message): + formula_type_value: "FormulaTypeValue" = betterproto.message_field(3) + game_formula_info: List["FormulaInfo"] = betterproto.message_field(11) + ilbkmnajgmo: List["MLPKNLLAOIF"] = betterproto.message_field(14) + + +@dataclass +class RogueCommonKeyword(betterproto.Message): + keyword_id: int = betterproto.uint32_field(7) + + +@dataclass +class RogueCommonRemoveKeyword(betterproto.Message): + keyword_id: int = betterproto.uint32_field(1) + + +@dataclass +class KeywordUnlockValue(betterproto.Message): + keyword_unlock_map: Dict[int, bool] = betterproto.map_field( + 7, betterproto.TYPE_UINT32, betterproto.TYPE_BOOL + ) + + +@dataclass +class RogueCommonActionResultData(betterproto.Message): + get_item_list: "RogueCommonMoney" = betterproto.message_field(2) + remove_item_list: "RogueCommonMoney" = betterproto.message_field( + 12 + ) + get_buff_list: "RogueCommonBuff" = betterproto.message_field(750) + remove_buff_list: "RogueCommonBuff" = betterproto.message_field( + 1776 + ) + get_miracle_list: "RogueCommonMiracle" = betterproto.message_field( + 1553 + ) + remove_miracle_list: "RogueCommonRemoveMiracle" = betterproto.message_field( + 1300 + ) + apfmfbbdcjk: "IBIBPOOPDEN" = betterproto.message_field(1675) + bmdjopghlca: "MAAAAGPJJFE" = betterproto.message_field(59) + ompbjjohpoo: "PBALOEJCGFN" = betterproto.message_field(1320) + iomjmeaomfi: "HBLNHGANBAB" = betterproto.message_field(1023) + bblgeemhiim: "MDGJIKLJDDE" = betterproto.message_field(546) + get_formula_list: "RogueCommonFormula" = betterproto.message_field( + 1045 + ) + remove_formula_list: "RogueCommonRemoveFormula" = betterproto.message_field( + 541 + ) + expand_formula_list: "RogueCommonExpandedFormula" = betterproto.message_field( + 294 + ) + contract_formula_list: "RogueCommonContractFormula" = betterproto.message_field( + 74 + ) + dmkgebhpipj: "FIPFPHBPHLH" = betterproto.message_field(1643) + path_buff_list: "RogueCommonPathBuff" = betterproto.message_field( + 1865 + ) + get_keyword_list: "RogueCommonKeyword" = betterproto.message_field( + 1469 + ) + remove_keyword_list: "RogueCommonRemoveKeyword" = betterproto.message_field( + 1160 + ) + dress_scepter_list: "RogueCommonDressScepter" = betterproto.message_field( + 587 + ) + get_scepter_list: "RogueCommonGetScepter" = betterproto.message_field( + 1521 + ) + kaailmgchok: "AEFFJLGFAMH" = betterproto.message_field(1743) + get_magic_unit_list: "RogueMagicGameUnitInfo" = betterproto.message_field( + 1388 + ) + remove_magic_unit_list: "RogueMagicGameUnitInfo" = betterproto.message_field( + 718 + ) + jgdaebnefka: "RogueMagicGameUnitInfo" = betterproto.message_field( + 1960 + ) + aoibhcmanfk: "RogueMagicGameScepterInfo" = betterproto.message_field( + 1424 + ) + mibobjidcad: "HOBKEOICBMI" = betterproto.message_field(1419) + edbpehabhbi: "LNAMGOMHGJB" = betterproto.message_field(1813) + cjohmipjhnm: "LNAMGOMHGJB" = betterproto.message_field(1708) + + +@dataclass +class RogueFormulaSelectInfo(betterproto.Message): + can_roll: bool = betterproto.bool_field(3) + hint_id: int = betterproto.uint32_field(9) + roll_formula_cost_data: "ItemCostData" = betterproto.message_field(4) + roll_formula_free_count: int = betterproto.uint32_field(11) + roll_formula_max_count: int = betterproto.uint32_field(6) + handbook_unlock_formula_id_list: List[int] = betterproto.uint32_field(7) + roll_formula_count: int = betterproto.uint32_field(8) + select_formula_id_list: List[int] = betterproto.uint32_field(1) + + +@dataclass +class RogueTournFormulaResult(betterproto.Message): + tourn_formula_id: int = betterproto.uint32_field(12) + + +@dataclass +class RogueTournFormulaCallback(betterproto.Message): + pass + + +@dataclass +class FHMAIANENPO(betterproto.Message): + select_hint_id: int = betterproto.uint32_field(1) + laldacmchfi: List[int] = betterproto.uint32_field(15) + + +@dataclass +class ONOOFHDEIDD(betterproto.Message): + tourn_formula_id: int = betterproto.uint32_field(8) + + +@dataclass +class HKJEGONGJNP(betterproto.Message): + pass + + +@dataclass +class KHGCDEIMLHN(betterproto.Message): + pass + + +@dataclass +class EHEFOMMBNAF(betterproto.Message): + rogue_formula_select_info: "RogueFormulaSelectInfo" = betterproto.message_field(3) + + +@dataclass +class BPDDOBAHPNA(betterproto.Message): + rogue_formula_select_info: "RogueFormulaSelectInfo" = betterproto.message_field(1) + + +@dataclass +class EKMAHAFGNGJ(betterproto.Message): + tourn_formula_id: int = betterproto.uint32_field(10) + + +@dataclass +class HBIBLKKEOAC(betterproto.Message): + pass + + +@dataclass +class LGCMEEPJMHA(betterproto.Message): + idignadndnf: int = betterproto.uint32_field(9) + + +@dataclass +class RogueMagicScepterDressInfo(betterproto.Message): + slot: int = betterproto.uint32_field(6) + dress_magic_unit_unique_id: int = betterproto.uint32_field(15) + type: int = betterproto.uint32_field(14) + + +@dataclass +class RogueMagicScepter(betterproto.Message): + level: int = betterproto.uint32_field(15) + scepter_id: int = betterproto.uint32_field(1) + + +@dataclass +class RogueMagicGameScepterInfo(betterproto.Message): + trench_count: Dict[int, int] = betterproto.map_field( + 9, betterproto.TYPE_UINT32, betterproto.TYPE_UINT32 + ) + locked_magic_unit_list: List["RogueMagicGameUnit"] = betterproto.message_field(1) + scepter_dress_info: List["RogueMagicScepterDressInfo"] = betterproto.message_field( + 2 + ) + modifier_content: "RogueMagicScepter" = betterproto.message_field(13) + + +@dataclass +class RogueMagicGameUnit(betterproto.Message): + level: int = betterproto.uint32_field(13) + magic_unit_id: int = betterproto.uint32_field(8) + + +@dataclass +class RogueMagicGameUnitInfo(betterproto.Message): + unique_id: int = betterproto.uint32_field(15) + game_magic_unit: "RogueMagicGameUnit" = betterproto.message_field(10) + + +@dataclass +class RogueCommonDressScepter(betterproto.Message): + update_scepter_info: "RogueMagicGameScepterInfo" = betterproto.message_field(5) + + +@dataclass +class RogueCommonGetScepter(betterproto.Message): + update_scepter_info: "RogueMagicGameScepterInfo" = betterproto.message_field(11) + + +@dataclass +class AEFFJLGFAMH(betterproto.Message): + update_scepter_info: "RogueMagicGameScepterInfo" = betterproto.message_field(4) + + +@dataclass +class OKECOPGKLEE(betterproto.Message): + pmgjicchhdl: "RogueMagicGameUnitInfo" = betterproto.message_field(1) + + +@dataclass +class PGAKDEJBOHF(betterproto.Message): + jfpjbbjlifk: "RogueMagicGameUnitInfo" = betterproto.message_field(9) + + +@dataclass +class RogueMagicUnitSelectInfo(betterproto.Message): + select_hint_id: int = betterproto.uint32_field(1) + fgdjamhokif: "RogueMagicGameUnit" = betterproto.message_field(10) + ckkekmjmabc: int = betterproto.uint32_field(13) + select_magic_units: List["RogueMagicGameUnit"] = betterproto.message_field(11) + igchbpakbcb: int = betterproto.uint32_field(15) + + +@dataclass +class KKAGNMEMKOG(betterproto.Message): + select_hint_id: int = betterproto.uint32_field(8) + select_magic_units: List["RogueMagicGameUnitInfo"] = betterproto.message_field(12) + + +@dataclass +class RogueMagicUnitSelectResult(betterproto.Message): + select_magic_unit: "RogueMagicGameUnit" = betterproto.message_field(12) + + +@dataclass +class IIPEGHDKHGD(betterproto.Message): + select_magic_unit: "RogueMagicGameUnitInfo" = betterproto.message_field(7) + + +@dataclass +class RogueMagicUnitSelectCallback(betterproto.Message): + pass + + +@dataclass +class ABPNCPOIJCI(betterproto.Message): + pass + + +@dataclass +class IMNNNJGGPAG(betterproto.Message): + pass + + +@dataclass +class IMDHPDBHEBC(betterproto.Message): + pass + + +@dataclass +class HOBKEOICBMI(betterproto.Message): + hkklpldnpkd: List[int] = betterproto.uint32_field(2) + eocipkgjfop: "RogueMagicGameUnitInfo" = betterproto.message_field(8) + + +@dataclass +class RogueMagicScepterSelectInfo(betterproto.Message): + select_hint_id: int = betterproto.uint32_field(1) + select_scepters: List["RogueMagicScepter"] = betterproto.message_field(14) + + +@dataclass +class RogueMagicScepterSelectResult(betterproto.Message): + select_scepter: "RogueMagicScepter" = betterproto.message_field(6) + abbmhpkgaik: bool = betterproto.bool_field(10) + + +@dataclass +class RogueMagicScepterSelectCallback(betterproto.Message): + pass + + +@dataclass +class IKCNDLJLAPP(betterproto.Message): + pass + + +@dataclass +class JKHKEBMOBEJ(betterproto.Message): + jbjggnbjkdj: "RogueMagicScepter" = betterproto.message_field(13) + + +@dataclass +class JCDLJBPHOMD(betterproto.Message): + ghelbobfpam: "RogueMagicScepter" = betterproto.message_field(10) + blciljenelo: bool = betterproto.bool_field(13) + + +@dataclass +class LGPGCJDOIBK(betterproto.Message): + pass + + +@dataclass +class LNAMGOMHGJB(betterproto.Message): + iboekjbomog: int = betterproto.uint32_field(8) + + +@dataclass +class CGJNHNMAMDH(betterproto.Message): + kdaoimpppki: List[int] = betterproto.uint32_field(10) + ldfgifdfpcf: int = betterproto.uint32_field(9) + jmcembehcoj: int = betterproto.int32_field(5) + + +@dataclass +class CGGBPJICHGF(betterproto.Message): + gbooalmikob: List[int] = betterproto.uint32_field(8) + select_hint_id: int = betterproto.uint32_field(14) + nclaehaijjb: int = betterproto.uint32_field(12) + obiedgmebdl: "NDKLJJIIMGM" = betterproto.enum_field(11) + + +@dataclass +class HAOJLHGNFPM(betterproto.Message): + jmehmhkbjah: int = betterproto.uint32_field(9) + + +@dataclass +class BLJOGGMJBMD(betterproto.Message): + pass + + +@dataclass +class PIGFBKOJNHG(betterproto.Message): + event_unique_id: int = betterproto.uint32_field(11) + + +@dataclass +class AJNAJINFJIC(betterproto.Message): + battle_event_id: int = betterproto.uint32_field(14) + is_win: bool = betterproto.bool_field(6) + + +@dataclass +class MNMLOAPBHNF(betterproto.Message): + event_unique_id: int = betterproto.uint32_field(11) + + +@dataclass +class SyncRogueCommonPendingActionScNotify(betterproto.Message): + action: "RogueCommonPendingAction" = betterproto.message_field(9) + rogue_sub_mode: int = betterproto.uint32_field(3) + + +@dataclass +class RogueCommonPendingAction(betterproto.Message): + queue_position: int = betterproto.uint32_field(1) + rogue_action: "RogueAction" = betterproto.message_field(15) + + +@dataclass +class RogueAction(betterproto.Message): + buff_select_info: "RogueCommonBuffSelectInfo" = betterproto.message_field( + 620 + ) + fphhhiobfai: "LEFCOMGMPCL" = betterproto.message_field(616) + ajddfancejn: "IPGKAGFFBHF" = betterproto.message_field(1501) + buff_reforge_select_info: "RogueCommonBuffReforgeSelectInfo" = ( + betterproto.message_field(1179) + ) + miracle_select_info: "RogueMiracleSelectInfo" = betterproto.message_field( + 19 + ) + bicjempplam: "ANMCAIMELCA" = betterproto.message_field(185) + aelpppiefab: "GABBEHOIPJC" = betterproto.message_field(1572) + bediachlcii: "MLKICCAELKE" = betterproto.message_field(1933) + ladgcoomnka: "EAKECFAPPKD" = betterproto.message_field(1334) + cgkfomncnak: "ELDAFCNMFBF" = betterproto.message_field(701) + compose_miracle_select_info: "RogueComposeMiracleSelectInfo" = ( + betterproto.message_field(608) + ) + hex_avatar_select_info: "RogueHexAvatarSelectInfo" = betterproto.message_field( + 306 + ) + bonus_select_info: "RogueBonusSelectInfo" = betterproto.message_field( + 1346 + ) + rogue_formula_select_info: "RogueFormulaSelectInfo" = betterproto.message_field( + 722 + ) + jbkpikajpeb: "FHMAIANENPO" = betterproto.message_field(1207) + hcchfjefanj: "BPDDOBAHPNA" = betterproto.message_field(1815) + oiomhopnimf: "RogueMagicUnitSelectInfo" = betterproto.message_field( + 522 + ) + ifclaafpkhc: "RogueMagicScepterSelectInfo" = betterproto.message_field( + 1078 + ) + hfjechfannf: "JKHKEBMOBEJ" = betterproto.message_field(308) + ldjomiojepf: "RogueMagicUnitSelectInfo" = betterproto.message_field( + 625 + ) + lmnoncmbioo: "RogueMagicUnitSelectInfo" = betterproto.message_field( + 1220 + ) + cnlmcobncai: "RogueMagicUnitSelectInfo" = betterproto.message_field( + 532 + ) + fhokdllicjl: "KKAGNMEMKOG" = betterproto.message_field(1108) + phdemdbgoib: "KKAGNMEMKOG" = betterproto.message_field(1142) + kljjibpjgff: "KKAGNMEMKOG" = betterproto.message_field(631) + dlfalfgfdhe: "PIGFBKOJNHG" = betterproto.message_field(1714) + npcdbpndgop: "CGGBPJICHGF" = betterproto.message_field(285) + + +@dataclass +class HandleRogueCommonPendingActionCsReq(betterproto.Message): + jkhbbdlchid: "RogueBuffSelectResult" = betterproto.message_field( + 1893 + ) + kbnegolplfc: "PBMAKLNJEKO" = betterproto.message_field(864) + gdkgibekgpf: "OKEFIDDNLKG" = betterproto.message_field(1478) + oncngiilenf: "RogueBuffRerollResult" = betterproto.message_field( + 754 + ) + glejcdpdjne: "RogueBuffReforgeSelectResult" = betterproto.message_field( + 1267 + ) + ooagpgdpjoa: "MPPHHNAEEDK" = betterproto.message_field(136) + idbaljbnbke: "JFPFDJPPOAG" = betterproto.message_field(1573) + gnebjeppkej: "NALELIGHDAA" = betterproto.message_field(817) + kjlafilapjf: "PKODMMPHIBC" = betterproto.message_field(427) + flfpcphlago: "NHCKHPLKLIO" = betterproto.message_field(1970) + epoakmfmflm: "LHJPIKEKPGH" = betterproto.message_field(461) + fkpfokhbpkk: "IMCBIIGOKPM" = betterproto.message_field(1861) + eodclaipcae: "LKMKHACMAPC" = betterproto.message_field(714) + aocodaobkhm: "IMLBIBJKPDB" = betterproto.message_field(2032) + egggggglfho: "RogueTournFormulaResult" = betterproto.message_field( + 234 + ) + lnploeofccj: "KHGCDEIMLHN" = betterproto.message_field(960) + ieabohkeapa: "ONOOFHDEIDD" = betterproto.message_field(106) + nediibjhgfo: "EKMAHAFGNGJ" = betterproto.message_field(1571) + jgpcbcjkonh: "RogueMagicUnitSelectResult" = betterproto.message_field( + 997 + ) + hknjipjhocg: "RogueMagicScepterSelectResult" = betterproto.message_field( + 1412 + ) + ldaglimnman: "JCDLJBPHOMD" = betterproto.message_field(395) + aflheikjnbn: "RogueMagicUnitSelectResult" = betterproto.message_field( + 1429 + ) + phkbflnpefi: "RogueMagicUnitSelectResult" = betterproto.message_field( + 232 + ) + gocmndkfoab: "RogueMagicUnitSelectResult" = betterproto.message_field( + 1036 + ) + chonecoliha: "IIPEGHDKHGD" = betterproto.message_field(1168) + moaogacboij: "IIPEGHDKHGD" = betterproto.message_field(1115) + kilhfppbbfm: "IIPEGHDKHGD" = betterproto.message_field(183) + blhdfajhcja: "HAOJLHGNFPM" = betterproto.message_field(71) + lpjbaimjaik: "HAOJLHGNFPM" = betterproto.message_field(1799) + ecegpejcpbl: "LGCMEEPJMHA" = betterproto.message_field(1027) + fkpdkfemkec: "AJNAJINFJIC" = betterproto.message_field(122087) + llnmcjcfbmj: "MNMLOAPBHNF" = betterproto.message_field(221323) + i_f_d_k_l_l_h_f_p_j_b: int = betterproto.uint32_field(9) + + +@dataclass +class HandleRogueCommonPendingActionScRsp(betterproto.Message): + pnadbjejbof: "RogueBuffSelectCallback" = betterproto.message_field( + 810 + ) + kkiangabfnj: "FKDBIHNPCHE" = betterproto.message_field(239) + cldbplniaen: "DLHPDALGDEH" = betterproto.message_field(553) + goomopmalol: "RogueBuffRerollCallback" = betterproto.message_field( + 653 + ) + kbflnjpmoah: "RogueBuffReforgeSelectCallback" = betterproto.message_field( + 1123 + ) + jkjofmhjgib: "CFFOCCHBAMH" = betterproto.message_field(1248) + dddenapjbka: "HONKBMJPJAA" = betterproto.message_field(672) + dmcepjkoogc: "PAOCONGELJK" = betterproto.message_field(1714) + fdppgkddpgc: "BLFJBKBHJIL" = betterproto.message_field(524) + mapbdbmfimd: "OMJFMBJMFMC" = betterproto.message_field(347) + oihjekimppd: "MOIKNHHCABH" = betterproto.message_field(1934) + okpcjlpmbad: "FHIKPLAIOEI" = betterproto.message_field(90) + dpgbcafkdpm: "NOCOCFHOAJC" = betterproto.message_field(1639) + hmobefjkdpd: "JCAHMIOOLDB" = betterproto.message_field(400) + japiiijmpge: "RogueTournFormulaCallback" = betterproto.message_field( + 1066 + ) + cpopchnddfm: "EHEFOMMBNAF" = betterproto.message_field(1688) + ndjbgfheici: "HKJEGONGJNP" = betterproto.message_field(1813) + cobeibnlgjf: "HBIBLKKEOAC" = betterproto.message_field(1856) + blefmehonoo: "RogueMagicUnitSelectCallback" = betterproto.message_field( + 639 + ) + ihbodkmfpnf: "RogueMagicScepterSelectCallback" = betterproto.message_field( + 1917 + ) + lbojliiabap: "LGPGCJDOIBK" = betterproto.message_field(1297) + ilhbhphdedl: "ABPNCPOIJCI" = betterproto.message_field(1554) + dicgeadecpk: "IMNNNJGGPAG" = betterproto.message_field(727) + gabicmfakpd: "IMDHPDBHEBC" = betterproto.message_field(629) + dkmmoimojdm: "IKCNDLJLAPP" = betterproto.message_field(1822) + hcfopgmleno: "BLJOGGMJBMD" = betterproto.message_field(771) + gdmgoelomfk: "BLJOGGMJBMD" = betterproto.message_field(1651) + i_f_d_k_l_l_h_f_p_j_b: int = betterproto.uint32_field(10) + queue_position: int = betterproto.uint32_field(11) + retcode: int = betterproto.uint32_field(4) + + +@dataclass +class FCPMBJHFBNJ(betterproto.Message): + maze_buff_id: int = betterproto.uint32_field(1) + + +@dataclass +class GIADLHEEPHD(betterproto.Message): + fhhgdpcecee: int = betterproto.uint32_field(14) + has_taken_reward: bool = betterproto.bool_field(5) + + +@dataclass +class LOGNKEKHBAI(betterproto.Message): + has_taken_reward: bool = betterproto.bool_field(15) + ajbepahcgik: int = betterproto.uint32_field(14) + + +@dataclass +class KNIJHGNJIJM(betterproto.Message): + level: int = betterproto.uint32_field(13) + aeon_id: int = betterproto.uint32_field(5) + dpmibdhkdae: List[int] = betterproto.uint32_field(9) + jgmipmdppij: int = betterproto.uint32_field(7) + ddgcfjdbooh: List[int] = betterproto.uint32_field(4) + exp: int = betterproto.uint32_field(8) + + +@dataclass +class OOCEOILKCFI(betterproto.Message): + magic_item: "RogueMagicScepter" = betterproto.message_field(14) + + +@dataclass +class RogueMagicUnitInfo(betterproto.Message): + ppmiogcfooc: int = betterproto.uint32_field(9) + magic_unit_id: int = betterproto.uint32_field(12) + + +@dataclass +class AEKNFLOMLJH(betterproto.Message): + miracle_list: List["GIADLHEEPHD"] = betterproto.message_field(6) + buff_list: List["FCPMBJHFBNJ"] = betterproto.message_field(8) + bjcmphlpknf: List["LOGNKEKHBAI"] = betterproto.message_field(2) + belofmfhfdk: List["KNIJHGNJIJM"] = betterproto.message_field(7) + + +@dataclass +class GetRogueHandbookDataCsReq(betterproto.Message): + pass + + +@dataclass +class GetRogueHandbookDataScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(15) + handbook_info: "AEKNFLOMLJH" = betterproto.message_field(14) + + +@dataclass +class SyncRogueHandbookDataUpdateScNotify(betterproto.Message): + bjkpkfbfdff: List["OOCEOILKCFI"] = betterproto.message_field(12) + haebaambnbb: List["LOGNKEKHBAI"] = betterproto.message_field(3) + abibobfdkld: List["FCPMBJHFBNJ"] = betterproto.message_field(11) + idddcjonpfn: List["GIADLHEEPHD"] = betterproto.message_field(7) + mmhchhcofpb: List["RogueMagicUnitInfo"] = betterproto.message_field(1) + + +@dataclass +class TakeRogueMiracleHandbookRewardCsReq(betterproto.Message): + afhddnggnbf: List[int] = betterproto.uint32_field(13) + + +@dataclass +class TakeRogueMiracleHandbookRewardScRsp(betterproto.Message): + reward: "ItemList" = betterproto.message_field(10) + retcode: int = betterproto.uint32_field(6) + feifjadcdfl: List[int] = betterproto.uint32_field(5) + + +@dataclass +class TakeRogueEventHandbookRewardCsReq(betterproto.Message): + handbook_buff_list: List[int] = betterproto.uint32_field(10) + + +@dataclass +class TakeRogueEventHandbookRewardScRsp(betterproto.Message): + dpjhilhgoke: List[int] = betterproto.uint32_field(4) + reward: "ItemList" = betterproto.message_field(6) + retcode: int = betterproto.uint32_field(9) + + +@dataclass +class RogueGameItemValue(betterproto.Message): + virtual_item: Dict[int, int] = betterproto.map_field( + 7, betterproto.TYPE_UINT32, betterproto.TYPE_UINT32 + ) + + +@dataclass +class ChessRogueGameAeonInfo(betterproto.Message): + bohdminejno: "EENDHPKPFLP" = betterproto.message_field(9) + icjabpgmacj: int = betterproto.int32_field(4) + game_aeon_id: int = betterproto.uint32_field(13) + + +@dataclass +class RogueDifficultyLevelInfo(betterproto.Message): + difficulty_id_list: List[int] = betterproto.uint32_field(13) + + +@dataclass +class RogueTournLineupInfo(betterproto.Message): + rogue_revive_cost: "ItemCostData" = betterproto.message_field(9) + avatar_id_list: List[int] = betterproto.uint32_field(2) + + +@dataclass +class RogueGameInfo(betterproto.Message): + rogue_buff_info: "ChessRogueBuffInfo" = betterproto.message_field( + 15 + ) + game_miracle_info: "ChessRogueMiracleInfo" = betterproto.message_field( + 6 + ) + fffccejifdk: "RogueGameItemValue" = betterproto.message_field(8) + rogue_aeon_info: "ChessRogueGameAeonInfo" = betterproto.message_field( + 1 + ) + rogue_difficulty_info: "RogueDifficultyLevelInfo" = betterproto.message_field( + 14 + ) + ckaanmddkcj: "RogueTournFormulaInfo" = betterproto.message_field( + 12 + ) + nbdacdnbjik: "KeywordUnlockValue" = betterproto.message_field(2) + rogue_lineup_info: "RogueTournLineupInfo" = betterproto.message_field( + 11 + ) + + +@dataclass +class PMJGKHPKHCM(betterproto.Message): + agebambkkbc: int = betterproto.uint32_field(6) + rogue_current_game_info: List["RogueGameInfo"] = betterproto.message_field(14) + sub_area_id: int = betterproto.uint32_field(11) + rogue_magic_battle_const: int = betterproto.uint32_field(12) + rogue_sub_mode: int = betterproto.uint32_field(15) + + +@dataclass +class RogueUnlockProgress(betterproto.Message): + finish: bool = betterproto.bool_field(11) + unlock_id: int = betterproto.uint32_field(2) + progress: int = betterproto.uint32_field(8) + + +@dataclass +class RogueTalentInfo(betterproto.Message): + rogue_unlock_progress_list: List["RogueUnlockProgress"] = betterproto.message_field( + 3 + ) + talent_id: int = betterproto.uint32_field(4) + status: "RogueTalentStatus" = betterproto.enum_field(7) + + +@dataclass +class RogueTalentInfoList(betterproto.Message): + talent_info: List["RogueTalentInfo"] = betterproto.message_field(6) + + +@dataclass +class RogueCommonVirtualItemInfo(betterproto.Message): + virtual_item_num: int = betterproto.uint32_field(14) + virtual_item_id: int = betterproto.uint32_field(1) + + +@dataclass +class SyncRogueCommonVirtualItemInfoScNotify(betterproto.Message): + common_item_info: List["RogueCommonVirtualItemInfo"] = betterproto.message_field(6) + + +@dataclass +class MAPOMOILGEH(betterproto.Message): + mbkfininnek: int = betterproto.uint32_field(12) + gedjniaefho: int = betterproto.uint32_field(5) + bdcffobgkoa: int = betterproto.uint32_field(10) + + +@dataclass +class PLGDCFIPEAA(betterproto.Message): + jpgcdjdgdbi: List["RogueUnlockFunctionType"] = betterproto.enum_field(15) + + +@dataclass +class ILAEKJCNEMF(betterproto.Message): + afedjkmfodp: List[int] = betterproto.uint32_field(4) + + +@dataclass +class LGJMDNNMPPE(betterproto.Message): + ongpjogkkjn: "MAPOMOILGEH" = betterproto.message_field(5) + nolhgnhaema: "ILAEKJCNEMF" = betterproto.message_field(15) + kjkbkegighk: "PLGDCFIPEAA" = betterproto.message_field(13) + + +@dataclass +class CommonRogueQueryCsReq(betterproto.Message): + pass + + +@dataclass +class CommonRogueQueryScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(3) + rogue_get_info: "LGJMDNNMPPE" = betterproto.message_field(13) + fhhbjlhajfj: int = betterproto.uint32_field(10) + + +@dataclass +class CommonRogueUpdateScNotify(betterproto.Message): + ongpjogkkjn: "MAPOMOILGEH" = betterproto.message_field(15) + kjkbkegighk: "PLGDCFIPEAA" = betterproto.message_field(3) + nolhgnhaema: "ILAEKJCNEMF" = betterproto.message_field(12) + + +@dataclass +class RogueCommonDialogueBasicInfo(betterproto.Message): + aeon_talk_id: int = betterproto.uint32_field(9) + talk_dialogue_id: int = betterproto.uint32_field(11) + + +@dataclass +class GNJAPOMLLHE(betterproto.Message): + bglehmkmapg: int = betterproto.uint32_field(6) + + +@dataclass +class CNHHPDHBMDC(betterproto.Message): + bglehmkmapg: int = betterproto.uint32_field(9) + + +@dataclass +class JIEAAFJENLK(betterproto.Message): + formula_id: int = betterproto.uint32_field(15) + + +@dataclass +class HPJLAFHHGJG(betterproto.Message): + bglehmkmapg: int = betterproto.uint32_field(7) + + +@dataclass +class AFCCAOACNAK(betterproto.Message): + dialogue_id: int = betterproto.uint32_field(8) + + +@dataclass +class RogueCommonDialogueInfo(betterproto.Message): + dialogue_basic_info: "RogueCommonDialogueBasicInfo" = betterproto.message_field( + 9 + ) + admahlaalnh: "GNJAPOMLLHE" = betterproto.message_field(4) + oddgcbpoplf: "CNHHPDHBMDC" = betterproto.message_field(8) + gmakhonaeph: "JIEAAFJENLK" = betterproto.message_field(2) + cacgekaankl: "HPJLAFHHGJG" = betterproto.message_field(6) + aggblhgkpfj: "AFCCAOACNAK" = betterproto.message_field(1) + + +@dataclass +class RogueCommonDialogueOptionDisplayInfo(betterproto.Message): + display_float_value: float = betterproto.float_field(14) + display_int_value: int = betterproto.int32_field(1) + + +@dataclass +class RogueCommonDialogueOptionBattleResultInfo(betterproto.Message): + battle_event_id: int = betterproto.uint32_field(7) + + +@dataclass +class NEBPGHDDEPC(betterproto.Message): + jefioihhclg: int = betterproto.int32_field(10) + + +@dataclass +class RogueCommonDialogueOptionResultInfo(betterproto.Message): + battle_result_info: "RogueCommonDialogueOptionBattleResultInfo" = ( + betterproto.message_field(8) + ) + hmlcehikffk: "NEBPGHDDEPC" = betterproto.message_field(4) + + +@dataclass +class RogueCommonDialogueOptionInfo(betterproto.Message): + is_valid: bool = betterproto.bool_field(14) + confirm: bool = betterproto.bool_field(6) + arg_id: int = betterproto.uint32_field(13) + option_result_info: List["RogueCommonDialogueOptionResultInfo"] = ( + betterproto.message_field(7) + ) + option_id: int = betterproto.uint32_field(12) + display_value: "RogueCommonDialogueOptionDisplayInfo" = betterproto.message_field(3) + + +@dataclass +class RogueCommonDialogueDataInfo(betterproto.Message): + option_list: List["RogueCommonDialogueOptionInfo"] = betterproto.message_field(4) + event_unique_id: int = betterproto.uint32_field(5) + dialogue_info: "RogueCommonDialogueInfo" = betterproto.message_field(11) + + +@dataclass +class GetRogueCommonDialogueDataCsReq(betterproto.Message): + pass + + +@dataclass +class GetRogueCommonDialogueDataScRsp(betterproto.Message): + dialogue_data_list: List["RogueCommonDialogueDataInfo"] = betterproto.message_field( + 9 + ) + retcode: int = betterproto.uint32_field(14) + + +@dataclass +class SelectRogueCommonDialogueOptionCsReq(betterproto.Message): + option_id: int = betterproto.uint32_field(9) + event_unique_id: int = betterproto.uint32_field(12) + + +@dataclass +class SelectRogueCommonDialogueOptionScRsp(betterproto.Message): + effect_event_id_list: List[int] = betterproto.uint32_field(4) + dialogue_data: "RogueCommonDialogueDataInfo" = betterproto.message_field(14) + event_unique_id: int = betterproto.uint32_field(2) + retcode: int = betterproto.uint32_field(11) + option_id: int = betterproto.uint32_field(10) + event_has_effect: bool = betterproto.bool_field(8) + + +@dataclass +class FinishRogueCommonDialogueCsReq(betterproto.Message): + event_unique_id: int = betterproto.uint32_field(6) + + +@dataclass +class FinishRogueCommonDialogueScRsp(betterproto.Message): + event_unique_id: int = betterproto.uint32_field(9) + retcode: int = betterproto.uint32_field(7) + + +@dataclass +class SyncRogueCommonDialogueDataScNotify(betterproto.Message): + dialogue_data_list: List["RogueCommonDialogueDataInfo"] = betterproto.message_field( + 1 + ) + + +@dataclass +class SyncRogueCommonDialogueOptionFinishScNotify(betterproto.Message): + dialogue_data: "RogueCommonDialogueDataInfo" = betterproto.message_field(12) + dgncfmdppbf: "RogueCommonDialogueOptionInfo" = betterproto.message_field(4) + option_id: int = betterproto.uint32_field(5) + event_unique_id: int = betterproto.uint32_field(9) + + +@dataclass +class RogueTournCurAreaInfo(betterproto.Message): + pending_action: "RogueCommonPendingAction" = betterproto.message_field(7) + mdlndgijnml: str = betterproto.string_field(9) + agebambkkbc: int = betterproto.uint32_field(4) + rogue_sub_mode: int = betterproto.uint32_field(8) + rogue_magic_battle_const: int = betterproto.uint32_field(3) + sub_area_id: int = betterproto.uint32_field(5) + + +@dataclass +class RogueWorkbenchGetInfoCsReq(betterproto.Message): + prop_entity_id: int = betterproto.uint32_field(10) + + +@dataclass +class RogueWorkbenchGetInfoScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(9) + func_info_map: Dict[int, "WorkbenchFuncInfo"] = betterproto.map_field( + 15, betterproto.TYPE_UINT32, betterproto.TYPE_MESSAGE + ) + + +@dataclass +class WorkbenchFuncInfo(betterproto.Message): + reforge_buff_func: "WorkbenchReforgeBuffFuncInfo" = betterproto.message_field( + 15 + ) + reforge_formula_func: "WorkbenchReforgeFormulaFuncInfo" = betterproto.message_field( + 8 + ) + enhance_buff_func: "WorkbenchEnhanceBuffFuncInfo" = betterproto.message_field( + 12 + ) + compose_miracle_func: "WorkbenchComposeMiracleFunc" = betterproto.message_field( + 11 + ) + reforge_hex_avatar_func: "WorkbenchReforgeHexAvatarFunc" = ( + betterproto.message_field(13) + ) + magic_item: "KHCBGNLNPEL" = betterproto.message_field(3) + game_magic_unit: "KMHIBNGAFEO" = betterproto.message_field(5) + ceajnliofhf: "DMKPFGEBILH" = betterproto.message_field(6) + pgpaapopdoc: "LFGGPNGKBCH" = betterproto.message_field(7) + pmkehgbpcng: "DHMFCIDJBFD" = betterproto.message_field(14) + + +@dataclass +class WorkbenchReforgeBuffFuncInfo(betterproto.Message): + free_reforge_num: int = betterproto.uint32_field(10) + can_free_reforge: bool = betterproto.bool_field(2) + cost_data: "ItemCostData" = betterproto.message_field(13) + int_reforge_num_value: int = betterproto.int32_field(15) + uint_reforge_num_value: int = betterproto.uint32_field(3) + + +@dataclass +class WorkbenchReforgeFormulaFuncInfo(betterproto.Message): + free_reforge_num: int = betterproto.uint32_field(10) + can_free_reforge: bool = betterproto.bool_field(3) + uint_reforge_num_value: int = betterproto.uint32_field(12) + int_reforge_num_value: int = betterproto.int32_field(2) + cost_data: "ItemCostData" = betterproto.message_field(13) + + +@dataclass +class WorkbenchEnhanceBuffFuncInfo(betterproto.Message): + buff_enhance_cost_map: Dict[int, int] = betterproto.map_field( + 9, betterproto.TYPE_UINT32, betterproto.TYPE_UINT32 + ) + cur_num: int = betterproto.uint32_field(14) + max_num: int = betterproto.uint32_field(13) + + +@dataclass +class WorkbenchComposeMiracleFunc(betterproto.Message): + cost_data: "ItemCostData" = betterproto.message_field(4) + int_reforge_num_value: int = betterproto.int32_field(5) + free_reforge_num: int = betterproto.uint32_field(14) + allow_to_compose_map: Dict[int, bool] = betterproto.map_field( + 10, betterproto.TYPE_UINT32, betterproto.TYPE_BOOL + ) + + +@dataclass +class WorkbenchReforgeHexAvatarFunc(betterproto.Message): + cost_data: "ItemCostData" = betterproto.message_field(6) + free_reforge_num: int = betterproto.uint32_field(3) + int_reforge_num_value: int = betterproto.int32_field(15) + + +@dataclass +class COAHGFLONAN(betterproto.Message): + cost_data: "ItemCostData" = betterproto.message_field(8) + hbpblgllien: "ItemCostData" = betterproto.message_field(6) + magic_item: "RogueMagicScepter" = betterproto.message_field(10) + ngkjpcehmba: bool = betterproto.bool_field(1) + + +@dataclass +class KHCBGNLNPEL(betterproto.Message): + rogue_magic_scepter_info_list: List["COAHGFLONAN"] = betterproto.message_field(13) + + +@dataclass +class AOGIIMKCJDJ(betterproto.Message): + ngkjpcehmba: bool = betterproto.bool_field(6) + magic_unit_id: int = betterproto.uint32_field(14) + cost_data: "ItemCostData" = betterproto.message_field(1) + hbpblgllien: "ItemCostData" = betterproto.message_field(4) + ppmiogcfooc: int = betterproto.uint32_field(9) + + +@dataclass +class KMHIBNGAFEO(betterproto.Message): + rogue_magic_unit_info_list: List["AOGIIMKCJDJ"] = betterproto.message_field(12) + + +@dataclass +class DMKPFGEBILH(betterproto.Message): + free_reforge_num: int = betterproto.uint32_field(4) + int_reforge_num_value: int = betterproto.int32_field(7) + cost_data: "ItemCostData" = betterproto.message_field(9) + + +@dataclass +class LFGGPNGKBCH(betterproto.Message): + int_reforge_num_value: int = betterproto.int32_field(1) + faidibodmch: "ItemCostData" = betterproto.message_field(2) + iakhmmelmfd: Dict[int, "ItemCostData"] = betterproto.map_field( + 7, betterproto.TYPE_UINT32, betterproto.TYPE_MESSAGE + ) + free_reforge_num: int = betterproto.uint32_field(11) + + +@dataclass +class KIFILCJOLCH(betterproto.Message): + cost_data: "ItemCostData" = betterproto.message_field(3) + scepter_id: int = betterproto.uint32_field(8) + + +@dataclass +class DHMFCIDJBFD(betterproto.Message): + magic_scepter_info_list: List["KIFILCJOLCH"] = betterproto.message_field(13) + + +@dataclass +class RogueWorkbenchHandleFuncCsReq(betterproto.Message): + prop_entity_id: int = betterproto.uint32_field(7) + func_id: int = betterproto.uint32_field(5) + workbench_content: "RogueWorkbenchContentInfo" = betterproto.message_field(6) + + +@dataclass +class RogueWorkbenchHandleFuncScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(1) + func_id: int = betterproto.uint32_field(8) + target_func_info: "WorkbenchFuncInfo" = betterproto.message_field(15) + + +@dataclass +class RogueWorkbenchContentInfo(betterproto.Message): + reforge_buff_func: "WorkbenchReforgeBuffTargetInfo" = betterproto.message_field( + 1 + ) + reforge_formula_func: "WorkbenchReforgeFormulaTargetInfo" = ( + betterproto.message_field(5) + ) + enhance_buff_func: "WorkbenchEnhanceBuffTargetInfo" = betterproto.message_field( + 11 + ) + compose_miracle_func: "WorkbenchComposeMiracleTargetInfo" = ( + betterproto.message_field(3) + ) + reforge_hex_avatar_func: "WorkbenchReforgeHexAvatarTargetInfo" = ( + betterproto.message_field(2) + ) + magic_item: "JDOOIDBKCIM" = betterproto.message_field(13) + game_magic_unit: "GJBBLCIPBHD" = betterproto.message_field(7) + ceajnliofhf: "LEHGLCELJMF" = betterproto.message_field(14) + pgpaapopdoc: "FHJGLOPMFNC" = betterproto.message_field(8) + pmkehgbpcng: "JBNCDFFPDOP" = betterproto.message_field(10) + + +@dataclass +class WorkbenchReforgeBuffTargetInfo(betterproto.Message): + target_reforge_buff_id: int = betterproto.uint32_field(8) + + +@dataclass +class WorkbenchReforgeFormulaTargetInfo(betterproto.Message): + target_reforge_formula_id: int = betterproto.uint32_field(13) + + +@dataclass +class WorkbenchEnhanceBuffTargetInfo(betterproto.Message): + target_buff_id: int = betterproto.uint32_field(13) + + +@dataclass +class WorkbenchComposeMiracleTargetInfo(betterproto.Message): + target_compose_miracle_id_list: List[int] = betterproto.uint32_field(14) + + +@dataclass +class WorkbenchReforgeHexAvatarTargetInfo(betterproto.Message): + target_reforge_hex_id: int = betterproto.uint32_field(5) + + +@dataclass +class JDOOIDBKCIM(betterproto.Message): + fpljoaacdgd: int = betterproto.uint32_field(15) + + +@dataclass +class GJBBLCIPBHD(betterproto.Message): + clopkobkhma: List[int] = betterproto.uint32_field(10) + + +@dataclass +class LEHGLCELJMF(betterproto.Message): + dnkccibpfgk: List[int] = betterproto.uint32_field(7) + + +@dataclass +class FHJGLOPMFNC(betterproto.Message): + magic_unit_id: int = betterproto.uint32_field(11) + + +@dataclass +class JBNCDFFPDOP(betterproto.Message): + scepter_id: int = betterproto.uint32_field(14) + + +@dataclass +class FKBFOOEFPAE(betterproto.Message): + infbhpgdlnd: int = betterproto.uint32_field(13) + status: "RogueCollectionStatus" = betterproto.enum_field(6) + + +@dataclass +class AJAKDCDDAMO(betterproto.Message): + infbhpgdlnd: int = betterproto.uint32_field(1) + status: "RogueBoothStatus" = betterproto.enum_field(15) + eonlmdcbnme: int = betterproto.uint32_field(3) + + +@dataclass +class GetRogueCollectionCsReq(betterproto.Message): + pass + + +@dataclass +class GetRogueCollectionScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(11) + pahpdbiacha: List["AJAKDCDDAMO"] = betterproto.message_field(4) + pcpedflnbga: List["FKBFOOEFPAE"] = betterproto.message_field(1) + + +@dataclass +class SetRogueCollectionCsReq(betterproto.Message): + fpipmkcagpd: List[int] = betterproto.uint32_field(6) + lghphfppjen: List["RogueCollectionExhibitionOperateType"] = betterproto.enum_field( + 13 + ) + opkmciffcch: List[int] = betterproto.uint32_field(9) + + +@dataclass +class SetRogueCollectionScRsp(betterproto.Message): + pcpedflnbga: List["FKBFOOEFPAE"] = betterproto.message_field(14) + retcode: int = betterproto.uint32_field(6) + pahpdbiacha: List["AJAKDCDDAMO"] = betterproto.message_field(11) + + +@dataclass +class GBPFLAGFAIJ(betterproto.Message): + status: "RogueExhibitionStatus" = betterproto.enum_field(4) + kbdfbginnbj: int = betterproto.uint32_field(8) + + +@dataclass +class DMODINLGCCB(betterproto.Message): + eonlmdcbnme: int = betterproto.uint32_field(12) + status: "RogueBoothStatus" = betterproto.enum_field(10) + kbdfbginnbj: int = betterproto.uint32_field(6) + + +@dataclass +class GetRogueExhibitionCsReq(betterproto.Message): + pass + + +@dataclass +class GetRogueExhibitionScRsp(betterproto.Message): + pjpjokkfnim: List["DMODINLGCCB"] = betterproto.message_field(13) + retcode: int = betterproto.uint32_field(1) + mkcefancaig: List["GBPFLAGFAIJ"] = betterproto.message_field(7) + + +@dataclass +class SetRogueExhibitionCsReq(betterproto.Message): + ldifbjdgffe: List[int] = betterproto.uint32_field(11) + anekpinlkfj: List["RogueCollectionExhibitionOperateType"] = betterproto.enum_field( + 10 + ) + heepoeolilo: List[int] = betterproto.uint32_field(7) + + +@dataclass +class SetRogueExhibitionScRsp(betterproto.Message): + pjpjokkfnim: List["DMODINLGCCB"] = betterproto.message_field(4) + mkcefancaig: List["GBPFLAGFAIJ"] = betterproto.message_field(1) + retcode: int = betterproto.uint32_field(12) + + +@dataclass +class EHKEGMCGCMH(betterproto.Message): + miracle_id: int = betterproto.uint32_field(1) + + +@dataclass +class PNDNJBBDHDP(betterproto.Message): + bimbfjgnpfb: int = betterproto.uint32_field(7) + level: int = betterproto.uint32_field(5) + + +@dataclass +class DOPJLBMMPHB(betterproto.Message): + djnabioeenf: "EHKEGMCGCMH" = betterproto.message_field(14) + imcajaogclg: "PNDNJBBDHDP" = betterproto.message_field(15) + k_d_g_b_j_g_o_p_e_h_i: bool = betterproto.bool_field(1) + b_i_m_b_f_j_g_n_p_f_b: int = betterproto.uint32_field(7) + + +@dataclass +class LOPJEJMOFBG(betterproto.Message): + group_id: int = betterproto.uint32_field(2) + bbpapddenhb: List["DOPJLBMMPHB"] = betterproto.message_field(14) + enbijbfbnec: bool = betterproto.bool_field(7) + + +@dataclass +class RogueGambleInfo(betterproto.Message): + ddjddbknpff: int = betterproto.uint32_field(6) + maze_group_list: List["LOPJEJMOFBG"] = betterproto.message_field(13) + loffeohfpfl: bool = betterproto.bool_field(15) + kedcohkknak: "ItemCostData" = betterproto.message_field(8) + akkonobbjnk: int = betterproto.uint32_field(2) + hfbkbhjiegd: int = betterproto.uint32_field(1) + cur_times: int = betterproto.uint32_field(4) + + +@dataclass +class RogueGetGambleInfoCsReq(betterproto.Message): + prop_entity_id: int = betterproto.uint32_field(11) + + +@dataclass +class RogueGetGambleInfoScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(15) + gamble_info: "RogueGambleInfo" = betterproto.message_field(8) + + +@dataclass +class RogueDoGambleCsReq(betterproto.Message): + prop_entity_id: int = betterproto.uint32_field(4) + + +@dataclass +class RogueDoGambleScRsp(betterproto.Message): + gamble_info: "RogueGambleInfo" = betterproto.message_field(7) + cfbglfojoda: int = betterproto.uint32_field(12) + jpklmppogdh: int = betterproto.uint32_field(1) + retcode: int = betterproto.uint32_field(5) + + +@dataclass +class RogueDebugReplaySaveScNotify(betterproto.Message): + jhjgfdmkihg: str = betterproto.string_field(14) + jdedckkacgo: str = betterproto.string_field(15) + nepgeejclah: str = betterproto.string_field(5) + kfamackfhpm: str = betterproto.string_field(12) + ijppknknlnl: str = betterproto.string_field(2) + uid: int = betterproto.uint32_field(1) + dfpfalbjhjh: str = betterproto.string_field(9) + + +@dataclass +class JNFELCKIOCM(betterproto.Message): + map_id: int = betterproto.uint32_field(8) + status: "RogueStatus" = betterproto.enum_field(10) + gmpiiaeggek: int = betterproto.uint32_field(15) + base_avatar_id_list: List[int] = betterproto.uint32_field(7) + chess_rogue_miracle_info: "ChessRogueMiracle" = betterproto.message_field(11) + ffkpegnbhod: int = betterproto.uint32_field(14) + trial_avatar_id_list: List[int] = betterproto.uint32_field(6) + chess_rogue_buff_info: "ChessRogueBuff" = betterproto.message_field(12) + kjgimhfkgbn: int = betterproto.uint32_field(9) + + +@dataclass +class OENDAFIAECG(betterproto.Message): + kkpkaljmamf: int = betterproto.uint32_field(5) + hdjcjbbknaf: int = betterproto.uint32_field(1) + aeieojgcmmo: int = betterproto.uint32_field(11) + bpekcejpofe: int = betterproto.uint32_field(12) + battle_id: int = betterproto.uint32_field(13) + is_rotate: bool = betterproto.bool_field(14) + jpkjkimnigg: int = betterproto.uint32_field(15) + hdllmdnlokp: int = betterproto.uint32_field(2) + + +@dataclass +class PEODOCNCLNP(betterproto.Message): + area_id: int = betterproto.uint32_field(6) + bopaangkogh: "OENDAFIAECG" = betterproto.message_field(1) + panel_id: int = betterproto.uint32_field(4) + aeloipgfodb: "JNFELCKIOCM" = betterproto.message_field(7) + + +@dataclass +class GetRogueEndlessActivityDataCsReq(betterproto.Message): + pass + + +@dataclass +class GetRogueEndlessActivityDataScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(14) + anameobfkgn: int = betterproto.uint32_field(2) + eahbikfallf: List[int] = betterproto.uint32_field(8) + data: List["PEODOCNCLNP"] = betterproto.message_field(7) + jchchlmdpen: int = betterproto.uint32_field(13) + + +@dataclass +class BBNHEMCKDIN(betterproto.Message): + avatar_type: "AvatarType" = betterproto.enum_field(8) + avatar_id: int = betterproto.uint32_field(2) + + +@dataclass +class EnterRogueEndlessActivityStageCsReq(betterproto.Message): + avatar_list: List["BBNHEMCKDIN"] = betterproto.message_field(13) + mgigdcmleog: int = betterproto.uint32_field(15) + + +@dataclass +class EnterRogueEndlessActivityStageScRsp(betterproto.Message): + battle_info: "SceneBattleInfo" = betterproto.message_field(14) + bopaangkogh: "OENDAFIAECG" = betterproto.message_field(12) + retcode: int = betterproto.uint32_field(9) + + +@dataclass +class RogueEndlessActivityBattleEndScNotify(betterproto.Message): + bopaangkogh: "OENDAFIAECG" = betterproto.message_field(15) + + +@dataclass +class TakeRogueEndlessActivityPointRewardCsReq(betterproto.Message): + level: int = betterproto.uint32_field(5) + mdhjkkbnmcf: bool = betterproto.bool_field(12) + + +@dataclass +class TakeRogueEndlessActivityPointRewardScRsp(betterproto.Message): + reward: "ItemList" = betterproto.message_field(10) + retcode: int = betterproto.uint32_field(1) + level: int = betterproto.uint32_field(5) + eahbikfallf: List[int] = betterproto.uint32_field(12) + mdhjkkbnmcf: bool = betterproto.bool_field(9) + jchchlmdpen: int = betterproto.uint32_field(2) + + +@dataclass +class TakeRogueEndlessActivityAllBonusRewardCsReq(betterproto.Message): + pass + + +@dataclass +class TakeRogueEndlessActivityAllBonusRewardScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(8) + eahbikfallf: List[int] = betterproto.uint32_field(10) + jchchlmdpen: int = betterproto.uint32_field(9) + reward: "ItemList" = betterproto.message_field(13) + + +@dataclass +class RogueMagicCurSceneInfo(betterproto.Message): + rotate_info: "RogueMapRotateInfo" = betterproto.message_field(3) + scene: "SceneInfo" = betterproto.message_field(14) + lineup: "LineupInfo" = betterproto.message_field(7) + + +@dataclass +class RogueMagicLayerInfo(betterproto.Message): + layer_id: int = betterproto.uint32_field(6) + status: "RogueMagicLayerStatus" = betterproto.enum_field(3) + cur_room_index: int = betterproto.uint32_field(4) + level_index: int = betterproto.uint32_field(1) + tourn_room_list: List["RogueMagicRoomInfo"] = betterproto.message_field(11) + + +@dataclass +class RogueMagicRoomInfo(betterproto.Message): + eipnnejnnkj: int = betterproto.uint32_field(14) + status: "RogueMagicRoomStatus" = betterproto.enum_field(5) + room_index: int = betterproto.uint32_field(7) + room_id: int = betterproto.uint32_field(9) + + +@dataclass +class RogueMagicGameLevelInfo(betterproto.Message): + acgbelaigbo: int = betterproto.uint32_field(4) + level_info_list: List["RogueMagicLayerInfo"] = betterproto.message_field(6) + status: "RogueMagicLevelStatus" = betterproto.enum_field(15) + cur_level_index: int = betterproto.uint32_field(2) + reason: "RogueMagicSettleReason" = betterproto.enum_field(1) + extra_round_limit: int = betterproto.uint32_field(9) + + +@dataclass +class RogueMagicGameItemInfo(betterproto.Message): + magic_scepter_info_list: List["RogueMagicGameScepterInfo"] = ( + betterproto.message_field(6) + ) + game_style_type: int = betterproto.uint32_field(7) + jfcnajmihci: bool = betterproto.bool_field(11) + rogue_magic_unit_info_list: List["RogueMagicGameUnitInfo"] = ( + betterproto.message_field(1) + ) + + +@dataclass +class RogueMagicGameDifficultyInfo(betterproto.Message): + difficulty_id_list: List[int] = betterproto.uint32_field(3) + + +@dataclass +class KLOHNFGBNPH(betterproto.Message): + laeejiikmpi: int = betterproto.uint32_field(3) + + +@dataclass +class RogueMagicStartCsReq(betterproto.Message): + select_style_type: int = betterproto.uint32_field(1) + start_difficulty_id_list: List[int] = betterproto.uint32_field(15) + area_id: int = betterproto.uint32_field(13) + base_avatar_id_list: List[int] = betterproto.uint32_field(6) + + +@dataclass +class RogueMagicCurInfo(betterproto.Message): + cacgekaankl: "KLOHNFGBNPH" = betterproto.message_field(15) + basic_info: "RogueTournCurAreaInfo" = betterproto.message_field(10) + miracle_info: "ChessRogueMiracleInfo" = betterproto.message_field(6) + magic_item: "RogueMagicGameItemInfo" = betterproto.message_field(5) + lineup: "RogueTournLineupInfo" = betterproto.message_field(2) + level: "RogueMagicGameLevelInfo" = betterproto.message_field(11) + game_difficulty_info: "RogueMagicGameDifficultyInfo" = betterproto.message_field(3) + item_value: "RogueGameItemValue" = betterproto.message_field(9) + + +@dataclass +class RogueMagicStartScRsp(betterproto.Message): + rogue_tourn_cur_info: "RogueMagicCurInfo" = betterproto.message_field(13) + rogue_tourn_cur_scene_info: "RogueMagicCurSceneInfo" = betterproto.message_field(2) + retcode: int = betterproto.uint32_field(7) + + +@dataclass +class RogueMagicEnterCsReq(betterproto.Message): + pass + + +@dataclass +class RogueMagicEnterScRsp(betterproto.Message): + rogue_tourn_cur_scene_info: "RogueMagicCurSceneInfo" = betterproto.message_field(4) + retcode: int = betterproto.uint32_field(8) + rogue_tourn_cur_info: "RogueMagicCurInfo" = betterproto.message_field(9) + + +@dataclass +class RogueMagicLeaveCsReq(betterproto.Message): + pass + + +@dataclass +class RogueMagicLeaveScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(7) + rogue_tourn_cur_scene_info: "RogueMagicCurSceneInfo" = betterproto.message_field(10) + + +@dataclass +class RogueMagicEnterRoomCsReq(betterproto.Message): + cur_room_index: int = betterproto.uint32_field(13) + fllablfbeik: int = betterproto.uint32_field(11) + + +@dataclass +class RogueMagicEnterRoomScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(7) + rogue_tourn_cur_scene_info: "RogueMagicCurSceneInfo" = betterproto.message_field(15) + + +@dataclass +class RogueMagicEnterLayerCsReq(betterproto.Message): + fllablfbeik: int = betterproto.uint32_field(5) + cur_level_index: int = betterproto.uint32_field(1) + + +@dataclass +class RogueMagicEnterLayerScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(1) + rogue_tourn_cur_scene_info: "RogueMagicCurSceneInfo" = betterproto.message_field(4) + + +@dataclass +class RogueMagicLevelInfoUpdateScNotify(betterproto.Message): + level_info_list: List["RogueMagicLayerInfo"] = betterproto.message_field(3) + reason: "RogueMagicSettleReason" = betterproto.enum_field(15) + acgbelaigbo: int = betterproto.uint32_field(2) + extra_round_limit: int = betterproto.uint32_field(1) + cur_level_index: int = betterproto.uint32_field(14) + status: "RogueMagicLevelStatus" = betterproto.enum_field(13) + + +@dataclass +class RogueMagicAreaUpdateScNotify(betterproto.Message): + rogue_tourn_area_info: List["RogueMagicAreaInfo"] = betterproto.message_field(13) + + +@dataclass +class CACLANLOOLK(betterproto.Message): + efkegdoajbh: int = betterproto.uint32_field(2) + fbjhgpdkbgm: bool = betterproto.bool_field(14) + + +@dataclass +class FJJDKDNDFDJ(betterproto.Message): + fbjhgpdkbgm: bool = betterproto.bool_field(2) + kknghgbhcgg: int = betterproto.uint32_field(9) + + +@dataclass +class OGNBIGKHHBM(betterproto.Message): + gcglnkfdkkn: "CACLANLOOLK" = betterproto.message_field(7) + bjlemfmcodd: "FJJDKDNDFDJ" = betterproto.message_field(4) + rogue_lineup_info: "LineupInfo" = betterproto.message_field(5) + rogue_tourn_cur_info: "RogueMagicCurInfo" = betterproto.message_field(3) + + +@dataclass +class HCJGPMDGBJO(betterproto.Message): + epckcookclj: List["RogueMagicGameUnit"] = betterproto.message_field(2) + blbfdcgceda: List[int] = betterproto.uint32_field(5) + klmgaebeagk: List["RogueMagicScepter"] = betterproto.message_field(3) + mnkcjfelcng: List[int] = betterproto.uint32_field(11) + + +@dataclass +class RogueMagicBattleFailSettleInfoScNotify(betterproto.Message): + tourn_finish_info: "OGNBIGKHHBM" = betterproto.message_field(1) + rogue_tourn_cur_scene_info: "RogueMagicCurSceneInfo" = betterproto.message_field(13) + + +@dataclass +class RogueMagicSettleCsReq(betterproto.Message): + pass + + +@dataclass +class RogueMagicSettleScRsp(betterproto.Message): + tourn_finish_info: "OGNBIGKHHBM" = betterproto.message_field(15) + mgcfoglkmch: "HCJGPMDGBJO" = betterproto.message_field(6) + retcode: int = betterproto.uint32_field(4) + gfonfdbfbna: "ItemList" = betterproto.message_field(8) + rogue_tourn_cur_scene_info: "RogueMagicCurSceneInfo" = betterproto.message_field(12) + + +@dataclass +class RogueMagicReviveCostUpdateScNotify(betterproto.Message): + rogue_revive_cost: "ItemCostData" = betterproto.message_field(14) + + +@dataclass +class RogueMagicReviveAvatarCsReq(betterproto.Message): + interacted_prop_entity_id: int = betterproto.uint32_field(11) + base_avatar_id_list: List[int] = betterproto.uint32_field(14) + + +@dataclass +class RogueMagicReviveAvatarScRsp(betterproto.Message): + rogue_revive_cost: "ItemCostData" = betterproto.message_field(12) + retcode: int = betterproto.uint32_field(4) + + +@dataclass +class RogueMagicQueryCsReq(betterproto.Message): + pass + + +@dataclass +class OLFGBAMEFJI(betterproto.Message): + blfdfmcffim: int = betterproto.uint32_field(10) + nnnkjkclblo: int = betterproto.uint32_field(9) + fonnghlgjfa: int = betterproto.uint32_field(6) + magic_scepter_info_list: List["RogueMagicGameScepterInfo"] = ( + betterproto.message_field(685) + ) + rogue_magic_unit_info_list: List["RogueMagicGameUnitInfo"] = ( + betterproto.message_field(1062) + ) + ofbiahgopcm: int = betterproto.uint32_field(8) + ipodnbljpol: int = betterproto.uint32_field(5) + njiempgeeog: int = betterproto.uint32_field(15) + hmkgbmidgop: int = betterproto.uint32_field(4) + extra_round_limit: int = betterproto.uint32_field(3) + jlhfojodokg: List[int] = betterproto.uint32_field(1190) + game_style_type: int = betterproto.uint32_field(2) + avatar_id_list: List[int] = betterproto.uint32_field(512) + + +@dataclass +class KOIICMIEAEF(betterproto.Message): + dpplcddhbge: List[int] = betterproto.uint32_field(1458) + + +@dataclass +class RogueMagicAreaInfo(betterproto.Message): + area_id: int = betterproto.uint32_field(6) + ifpoilopfag: int = betterproto.uint32_field(14) + is_taken_reward: bool = betterproto.bool_field(11) + npbnmmkhkop: List[int] = betterproto.uint32_field(13) + record_info: "OLFGBAMEFJI" = betterproto.message_field(5) + is_unlocked: bool = betterproto.bool_field(7) + cgaijcclkbh: "KOIICMIEAEF" = betterproto.message_field(1) + completed: bool = betterproto.bool_field(12) + + +@dataclass +class RogueMagicDifficultyInfo(betterproto.Message): + is_unlocked: bool = betterproto.bool_field(13) + difficulty_id: int = betterproto.uint32_field(6) + + +@dataclass +class RogueMagicStoryInfo(betterproto.Message): + finished_magic_story_list: List[int] = betterproto.uint32_field(9) + + +@dataclass +class RogueMagicGetInfo(betterproto.Message): + rogue_tourn_difficulty_info: List["RogueMagicDifficultyInfo"] = ( + betterproto.message_field(14) + ) + rogue_magic_scepter_info_list: List["OOCEOILKCFI"] = betterproto.message_field(2) + kglbndeaphf: List[int] = betterproto.uint32_field(5) + rogue_magic_talent_info: "RogueMagicTalentInfo" = betterproto.message_field(13) + story_info: "RogueMagicStoryInfo" = betterproto.message_field(9) + rogue_tourn_area_info: List["RogueMagicAreaInfo"] = betterproto.message_field(4) + rogue_magic_unit_info_list: List["RogueMagicUnitInfo"] = betterproto.message_field( + 12 + ) + + +@dataclass +class RogueMagicQueryScRsp(betterproto.Message): + rogue_tourn_cur_info: "RogueMagicCurInfo" = betterproto.message_field(4) + retcode: int = betterproto.uint32_field(7) + rogue_get_info: "RogueMagicGetInfo" = betterproto.message_field(11) + + +@dataclass +class RogueMagicScepterDressInUnitCsReq(betterproto.Message): + scepter_id: int = betterproto.uint32_field(12) + dress_magic_unit_unique_id: int = betterproto.uint32_field(7) + dice_slot_id: int = betterproto.uint32_field(5) + + +@dataclass +class RogueMagicScepterDressInUnitScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(2) + + +@dataclass +class RogueMagicAutoDressInUnitCsReq(betterproto.Message): + bhkankfpdcp: List[int] = betterproto.uint32_field(4) + + +@dataclass +class RogueMagicAutoDressInUnitScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(6) + + +@dataclass +class RogueMagicSetAutoDressInMagicUnitCsReq(betterproto.Message): + khdhahnnalm: bool = betterproto.bool_field(5) + + +@dataclass +class RogueMagicSetAutoDressInMagicUnitScRsp(betterproto.Message): + khdhahnnalm: bool = betterproto.bool_field(1) + retcode: int = betterproto.uint32_field(3) + + +@dataclass +class RogueMagicAutoDressInMagicUnitChangeScNotify(betterproto.Message): + khdhahnnalm: bool = betterproto.bool_field(5) + + +@dataclass +class RogueMagicScepterTakeOffUnitCsReq(betterproto.Message): + scepter_id: int = betterproto.uint32_field(8) + bhkankfpdcp: List[int] = betterproto.uint32_field(13) + + +@dataclass +class RogueMagicScepterTakeOffUnitScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(15) + + +@dataclass +class RogueMagicUnitComposeCsReq(betterproto.Message): + bhkankfpdcp: List[int] = betterproto.uint32_field(10) + + +@dataclass +class RogueMagicUnitComposeScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(14) + + +@dataclass +class RogueMagicUnitReforgeCsReq(betterproto.Message): + bhkankfpdcp: List[int] = betterproto.uint32_field(4) + + +@dataclass +class RogueMagicUnitReforgeScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(8) + + +@dataclass +class RogueMagicTalentInfo(betterproto.Message): + cmadmlialjl: int = betterproto.uint32_field(1) + talent_info_list: "RogueTalentInfoList" = betterproto.message_field(13) + + +@dataclass +class RogueMagicGetTalentInfoCsReq(betterproto.Message): + pass + + +@dataclass +class RogueMagicGetTalentInfoScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(14) + rogue_magic_talent_info: "RogueMagicTalentInfo" = betterproto.message_field(12) + + +@dataclass +class RogueMagicEnableTalentCsReq(betterproto.Message): + talent_id: int = betterproto.uint32_field(3) + + +@dataclass +class RogueMagicEnableTalentScRsp(betterproto.Message): + rogue_magic_talent_info: "RogueMagicTalentInfo" = betterproto.message_field(4) + retcode: int = betterproto.uint32_field(7) + + +@dataclass +class RogueMagicGetMiscRealTimeDataCsReq(betterproto.Message): + pass + + +@dataclass +class RogueMagicGetMiscRealTimeDataScRsp(betterproto.Message): + gcglnkfdkkn: "CACLANLOOLK" = betterproto.message_field(9) + retcode: int = betterproto.uint32_field(6) + bjlemfmcodd: "FJJDKDNDFDJ" = betterproto.message_field(8) + + +@dataclass +class RogueMagicStoryInfoUpdateScNotify(betterproto.Message): + mnbccbabcha: int = betterproto.uint32_field(9) + + +@dataclass +class EDDHMIGFDJI(betterproto.Message): + mbgkckldhib: int = betterproto.uint32_field(9) + confirm: bool = betterproto.bool_field(5) + select_cell_id: int = betterproto.uint32_field(4) + + +@dataclass +class FOIACPFKDHK(betterproto.Message): + confirm: bool = betterproto.bool_field(3) + mbgkckldhib: int = betterproto.uint32_field(2) + select_cell_id: int = betterproto.uint32_field(7) + onnjgdjnflg: List[int] = betterproto.uint32_field(5) + + +@dataclass +class POGCNJMNGPI(betterproto.Message): + onnjgdjnflg: List[int] = betterproto.uint32_field(9) + confirm: bool = betterproto.bool_field(8) + select_cell_id: int = betterproto.uint32_field(12) + + +@dataclass +class AINBLBBFDBJ(betterproto.Message): + confirm: bool = betterproto.bool_field(4) + nhgojdodgma: List[int] = betterproto.uint32_field(3) + nijagoajpem: int = betterproto.uint32_field(5) + select_cell_id: int = betterproto.uint32_field(9) + + +@dataclass +class AJEEIAKEMIP(betterproto.Message): + cehfiilmjkm: int = betterproto.uint32_field(9) + + +@dataclass +class KHMJBJLOBPG(betterproto.Message): + cpocngekiib: int = betterproto.uint32_field(6) + + +@dataclass +class GFGDODHMBPK(betterproto.Message): + kokpceamabc: int = betterproto.uint32_field(13) + + +@dataclass +class NPDIPKHDCNF(betterproto.Message): + select_cell_id: int = betterproto.uint32_field(5) + block_type: int = betterproto.uint32_field(1) + nhgojdodgma: List[int] = betterproto.uint32_field(6) + confirm: bool = betterproto.bool_field(14) + + +@dataclass +class EGALAGNAEFB(betterproto.Message): + gpdeiiioipn: int = betterproto.uint32_field(7) + olgljhecdof: int = betterproto.uint32_field(3) + gclebgddiip: int = betterproto.uint32_field(15) + + +@dataclass +class NDGLJKNKEFK(betterproto.Message): + maze_buff_id: int = betterproto.uint32_field(1) + + +@dataclass +class EGFDAJDIHNJ(betterproto.Message): + item_id: int = betterproto.uint32_field(1) + item_count: int = betterproto.uint32_field(12) + + +@dataclass +class PNIKOFBIMJL(betterproto.Message): + nejdmegnfgk: int = betterproto.uint32_field(5) + eoaefbknffe: int = betterproto.uint32_field(13) + num: int = betterproto.uint32_field(12) + + +@dataclass +class JJDKOEEHBJO(betterproto.Message): + num: int = betterproto.uint32_field(6) + ooofgdbldce: int = betterproto.uint32_field(13) + + +@dataclass +class OKGMDMJHCMK(betterproto.Message): + cehfiilmjkm: int = betterproto.uint32_field(4) + + +@dataclass +class CFKBHPNBCNB(betterproto.Message): + mbgkckldhib: int = betterproto.uint32_field(3) + + +@dataclass +class BBBEOEOIFJK(betterproto.Message): + onnjgdjnflg: List[int] = betterproto.uint32_field(10) + select_cell_id: int = betterproto.uint32_field(13) + confirm: bool = betterproto.bool_field(12) + + +@dataclass +class AHPNAPGPJEG(betterproto.Message): + maze_buff_id: int = betterproto.uint32_field(1) + amojfmfeoge: int = betterproto.uint32_field(9) + + +@dataclass +class RogueModifierContent(betterproto.Message): + modifier_content_type: "RogueModifierContentType" = betterproto.enum_field(10) + content_modifier_effect_id: int = betterproto.uint32_field(3) + affjhmjdibn: int = betterproto.uint32_field(8) + + +@dataclass +class ChessRogueModifierInfo(betterproto.Message): + modifier_effect_cell_id_list: List[int] = betterproto.uint32_field(1) + confirm: bool = betterproto.bool_field(7) + select_cell_id: int = betterproto.uint32_field(6) + + +@dataclass +class MDBJBIEKKEE(betterproto.Message): + lipapomhmce: int = betterproto.uint32_field(6) + + +@dataclass +class BLCPNBIKCLP(betterproto.Message): + count: int = betterproto.uint32_field(4) + + +@dataclass +class RogueModifier(betterproto.Message): + modifier_info: "ChessRogueModifierInfo" = betterproto.message_field( + 1234 + ) + modifier_id: int = betterproto.uint64_field(12) + modifier_content: "RogueModifierContent" = betterproto.message_field(9) + modifier_source_type: "RogueModifierSourceType" = betterproto.enum_field(2) + + +@dataclass +class EENDHPKPFLP(betterproto.Message): + mebjclenpio: List["RogueModifier"] = betterproto.message_field(11) + + +@dataclass +class RogueModifierAddNotify(betterproto.Message): + modifier: "RogueModifier" = betterproto.message_field(6) + + +@dataclass +class RogueModifierSelectCellCsReq(betterproto.Message): + cell_id: int = betterproto.uint32_field(6) + + +@dataclass +class RogueModifierSelectCellScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(1) + cell_id: int = betterproto.uint32_field(6) + jdijkegcibp: "ItemList" = betterproto.message_field(3) + + +@dataclass +class RogueModifierUpdateNotify(betterproto.Message): + modifier: "RogueModifier" = betterproto.message_field(3) + + +@dataclass +class RogueModifierDelNotify(betterproto.Message): + modifier_id: int = betterproto.uint64_field(15) + + +@dataclass +class RogueModifierStageStartNotify(betterproto.Message): + modifier_source_type: "RogueModifierSourceType" = betterproto.enum_field(9) + + +@dataclass +class RogueTournCurSceneInfo(betterproto.Message): + scene: "SceneInfo" = betterproto.message_field(4) + lineup: "LineupInfo" = betterproto.message_field(5) + rotate_info: "RogueMapRotateInfo" = betterproto.message_field(1) + + +@dataclass +class RogueTournCurInfo(betterproto.Message): + rogue_tourn_cur_game_info: "RogueTournCurGameInfo" = betterproto.message_field( + 1752 + ) + rogue_tourn_cur_area_info: "RogueTournCurAreaInfo" = betterproto.message_field(6) + + +@dataclass +class NKPKIAAMODG(betterproto.Message): + jdbahpebfjc: int = betterproto.uint32_field(10) + mnnkjpliilj: int = betterproto.uint32_field(6) + ldfehkdcnel: int = betterproto.uint32_field(14) + fbjhgpdkbgm: bool = betterproto.bool_field(1) + + +@dataclass +class NNIJCDKHPKL(betterproto.Message): + fbjhgpdkbgm: bool = betterproto.bool_field(15) + jedjbedkcji: int = betterproto.uint32_field(6) + aiplflibpkj: int = betterproto.uint32_field(7) + cdinhfhbmog: int = betterproto.uint32_field(12) + + +@dataclass +class GPNJMEHNDMN(betterproto.Message): + hipjhpjolbe: int = betterproto.uint32_field(6) + fbjhgpdkbgm: bool = betterproto.bool_field(10) + japdcmjpiej: int = betterproto.uint32_field(2) + + +@dataclass +class FBHNFJCNHML(betterproto.Message): + fbjhgpdkbgm: bool = betterproto.bool_field(14) + japdcmjpiej: int = betterproto.uint32_field(3) + + +@dataclass +class RogueTournModuleInfo(betterproto.Message): + allow_food: bool = betterproto.bool_field(13) + + +@dataclass +class RogueTournCurGameInfo(betterproto.Message): + jmidlldkjbi: "CGJNHNMAMDH" = betterproto.message_field(13) + tourn_module_info: "RogueTournModuleInfo" = betterproto.message_field(9) + item_value: "RogueGameItemValue" = betterproto.message_field(2) + level: "RogueTournLevelInfo" = betterproto.message_field(1) + miracle_info: "ChessRogueMiracleInfo" = betterproto.message_field(14) + rogue_tourn_game_area_info: "RogueTournGameAreaInfo" = betterproto.message_field(5) + game_difficulty_info: "RogueTournGameDifficultyInfo" = betterproto.message_field(10) + tourn_formula_info: "RogueTournFormulaInfo" = betterproto.message_field(8) + lineup: "RogueTournLineupInfo" = betterproto.message_field(3) + unlock_value: "KeywordUnlockValue" = betterproto.message_field(15) + buff: "ChessRogueBuffInfo" = betterproto.message_field(12) + + +@dataclass +class RogueTournLevelInfo(betterproto.Message): + ejoijgclcjo: bool = betterproto.bool_field(2) + status: "RogueTournLevelStatus" = betterproto.enum_field(9) + lgbohdicfpk: bool = betterproto.bool_field(6) + level_info_list: List["RogueTournLevel"] = betterproto.message_field(8) + reason: "RogueTournSettleReason" = betterproto.enum_field(14) + cur_level_index: int = betterproto.uint32_field(4) + + +@dataclass +class RogueTournGameAreaInfo(betterproto.Message): + game_week: int = betterproto.uint32_field(3) + game_area_id: int = betterproto.uint32_field(13) + + +@dataclass +class RogueTournGameDifficultyInfo(betterproto.Message): + difficulty_id_list: List[int] = betterproto.uint32_field(13) + + +@dataclass +class RogueTournLevel(betterproto.Message): + tourn_room_list: List["RogueTournRoomList"] = betterproto.message_field(2) + status: "RogueTournLayerStatus" = betterproto.enum_field(13) + layer_id: int = betterproto.uint32_field(15) + cur_room_index: int = betterproto.uint32_field(9) + level_index: int = betterproto.uint32_field(4) + + +@dataclass +class RogueTournRoomList(betterproto.Message): + room_index: int = betterproto.uint32_field(14) + room_id: int = betterproto.uint32_field(4) + eipnnejnnkj: int = betterproto.uint32_field(15) + status: "RogueTournRoomStatus" = betterproto.enum_field(1) + + +@dataclass +class RogueTournStartCsReq(betterproto.Message): + base_avatar_id_list: List[int] = betterproto.uint32_field(15) + lgbohdicfpk: bool = betterproto.bool_field(1) + ejoijgclcjo: bool = betterproto.bool_field(11) + area_id: int = betterproto.uint32_field(2) + + +@dataclass +class RogueTournStartScRsp(betterproto.Message): + week: int = betterproto.uint32_field(3) + rogue_tourn_cur_info: "RogueTournCurInfo" = betterproto.message_field(11) + rogue_tourn_cur_scene_info: "RogueTournCurSceneInfo" = betterproto.message_field(1) + retcode: int = betterproto.uint32_field(13) + + +@dataclass +class RogueTournEnterCsReq(betterproto.Message): + pass + + +@dataclass +class RogueTournEnterScRsp(betterproto.Message): + rogue_tourn_cur_info: "RogueTournCurInfo" = betterproto.message_field(10) + rogue_tourn_cur_scene_info: "RogueTournCurSceneInfo" = betterproto.message_field(14) + retcode: int = betterproto.uint32_field(4) + + +@dataclass +class RogueTournLeaveCsReq(betterproto.Message): + pass + + +@dataclass +class RogueTournLeaveScRsp(betterproto.Message): + rogue_tourn_cur_scene_info: "RogueTournCurSceneInfo" = betterproto.message_field(4) + retcode: int = betterproto.uint32_field(11) + + +@dataclass +class RogueTournSettleCsReq(betterproto.Message): + pass + + +@dataclass +class RogueTournFinishInfo(betterproto.Message): + clkhpondddo: "KCLCHJMNPGL" = betterproto.message_field(15) + rogue_lineup_info: "LineupInfo" = betterproto.message_field(13) + kgciaiafibe: "GPNJMEHNDMN" = betterproto.message_field(3) + gcglnkfdkkn: "NNIJCDKHPKL" = betterproto.message_field(6) + cjcojamleel: "NKPKIAAMODG" = betterproto.message_field(2) + rogue_tourn_cur_info: "RogueTournCurInfo" = betterproto.message_field(5) + pfoepfphfnj: "FBHNFJCNHML" = betterproto.message_field(4) + + +@dataclass +class RogueTournSettleScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(11) + tourn_finish_info: "RogueTournFinishInfo" = betterproto.message_field(7) + rogue_tourn_cur_scene_info: "RogueTournCurSceneInfo" = betterproto.message_field(12) + + +@dataclass +class RogueTournEnterRoomCsReq(betterproto.Message): + cur_room_index: int = betterproto.uint32_field(15) + fllablfbeik: int = betterproto.uint32_field(7) + + +@dataclass +class RogueTournEnterRoomScRsp(betterproto.Message): + rogue_tourn_cur_scene_info: "RogueTournCurSceneInfo" = betterproto.message_field(7) + retcode: int = betterproto.uint32_field(5) + + +@dataclass +class RogueTournEnterLayerCsReq(betterproto.Message): + fllablfbeik: int = betterproto.uint32_field(4) + cur_level_index: int = betterproto.uint32_field(11) + + +@dataclass +class RogueTournEnterLayerScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(2) + rogue_tourn_cur_scene_info: "RogueTournCurSceneInfo" = betterproto.message_field(5) + + +@dataclass +class RogueTournLevelInfoUpdateScNotify(betterproto.Message): + level_info_list: List["RogueTournLevel"] = betterproto.message_field(12) + status: "RogueTournLevelStatus" = betterproto.enum_field(14) + reason: "RogueTournSettleReason" = betterproto.enum_field(9) + cur_level_index: int = betterproto.uint32_field(15) + + +@dataclass +class RogueTournTakeExpRewardCsReq(betterproto.Message): + sub_tourn_id: int = betterproto.uint32_field(15) + lopmhjfbhim: List[int] = betterproto.uint32_field(10) + + +@dataclass +class RogueTournTakeExpRewardScRsp(betterproto.Message): + exp: int = betterproto.uint32_field(9) + reward: "ItemList" = betterproto.message_field(5) + retcode: int = betterproto.uint32_field(6) + taken_level_rewards: List[int] = betterproto.uint32_field(10) + + +@dataclass +class RogueTournExpNotify(betterproto.Message): + exp: int = betterproto.uint32_field(13) + + +@dataclass +class RogueTournQueryCsReq(betterproto.Message): + pass + + +@dataclass +class RogueTournAreaInfo(betterproto.Message): + unlocked_tourn_difficulty_list: List[int] = betterproto.uint32_field(4) + completed: bool = betterproto.bool_field(14) + area_id: int = betterproto.uint32_field(7) + gmopljjgbpo: bool = betterproto.bool_field(13) + is_unlocked: bool = betterproto.bool_field(12) + is_taken_reward: bool = betterproto.bool_field(8) + + +@dataclass +class ExtraScoreInfo(betterproto.Message): + lfpccpoljpc: int = betterproto.uint32_field(3) + week: int = betterproto.uint32_field(12) + end_time: int = betterproto.int64_field(14) + gpodhhaohnp: bool = betterproto.bool_field(6) + + +@dataclass +class RogueTournExpInfo(betterproto.Message): + exp: int = betterproto.uint32_field(2) + taken_level_rewards: List[int] = betterproto.uint32_field(9) + + +@dataclass +class RogueTournPermanentTalentInfo(betterproto.Message): + tourn_talent_coin_num: int = betterproto.uint32_field(7) + talent_info_list: "RogueTalentInfoList" = betterproto.message_field(14) + + +@dataclass +class RogueTournDifficultyInfo(betterproto.Message): + is_unlocked: bool = betterproto.bool_field(7) + difficulty_id: int = betterproto.uint32_field(3) + + +@dataclass +class RogueTournSeasonInfo(betterproto.Message): + main_tourn_id: int = betterproto.uint32_field(15) + sub_tourn_id: int = betterproto.uint32_field(2) + + +@dataclass +class RogueTournHandbookInfo(betterproto.Message): + rogue_tourn_handbook_const: int = betterproto.uint32_field(6) + nffbjbbcdmg: List[int] = betterproto.uint32_field(11) + ppconkkpipm: List[int] = betterproto.uint32_field(7) + fajcnmekknn: List[int] = betterproto.uint32_field(2) + handbook_buff_list: List[int] = betterproto.uint32_field(5) + kcdlmnincge: List[int] = betterproto.uint32_field(3) + bkgjpcclidn: List[int] = betterproto.uint32_field(15) + + +@dataclass +class KCLCHJMNPGL(betterproto.Message): + ofgbjcccike: int = betterproto.uint32_field(6) + ngiambeihpi: int = betterproto.uint32_field(13) + + +@dataclass +class RogueTournInfo(betterproto.Message): + rogue_tourn_difficulty_info: List["RogueTournDifficultyInfo"] = ( + betterproto.message_field(7) + ) + permanent_info: "RogueTournPermanentTalentInfo" = betterproto.message_field(11) + rogue_tourn_handbook: "RogueTournHandbookInfo" = betterproto.message_field(4) + rogue_tourn_exp_info: "RogueTournExpInfo" = betterproto.message_field(13) + extra_score_info: "ExtraScoreInfo" = betterproto.message_field(2) + rogue_season_info: "RogueTournSeasonInfo" = betterproto.message_field(14) + llaoogchhdk: "GIGPOFFBIEO" = betterproto.message_field(12) + rogue_tourn_save_list: List["RogueTournSaveList"] = betterproto.message_field(3) + rogue_tourn_area_info: List["RogueTournAreaInfo"] = betterproto.message_field(8) + lkcefcljcbm: "KCLCHJMNPGL" = betterproto.message_field(15) + + +@dataclass +class RogueTournQueryScRsp(betterproto.Message): + rogue_get_info: "RogueTournInfo" = betterproto.message_field(1) + retcode: int = betterproto.uint32_field(7) + rogue_tourn_cur_info: "RogueTournCurInfo" = betterproto.message_field(13) + + +@dataclass +class RogueTournAreaUpdateScNotify(betterproto.Message): + rogue_tourn_area_info: List["RogueTournAreaInfo"] = betterproto.message_field(8) + + +@dataclass +class RogueTournSaveList(betterproto.Message): + rogue_tourn_cur_info: "RogueTournCurInfo" = betterproto.message_field(15) + end_time: int = betterproto.int64_field(3) + time: int = betterproto.int64_field(10) + max_times: int = betterproto.uint32_field(8) + name: str = betterproto.string_field(12) + rogue_season_info: "RogueTournSeasonInfo" = betterproto.message_field(13) + data: "BKFFNNAIODC" = betterproto.message_field(4) + + +@dataclass +class BKFFNNAIODC(betterproto.Message): + miracle_list: List["GameRogueMiracle"] = betterproto.message_field(5) + item_value: int = betterproto.uint32_field(12) + buff_list: List["RogueCommonBuff"] = betterproto.message_field(6) + + +@dataclass +class RogueTournGetAllArchiveCsReq(betterproto.Message): + pass + + +@dataclass +class RogueTournGetAllArchiveScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(1) + edjpodpnmed: List["RogueTournSaveList"] = betterproto.message_field(13) + + +@dataclass +class RogueTournDeleteArchiveCsReq(betterproto.Message): + max_times: int = betterproto.uint32_field(11) + + +@dataclass +class RogueTournDeleteArchiveScRsp(betterproto.Message): + max_times: int = betterproto.uint32_field(8) + retcode: int = betterproto.uint32_field(13) + + +@dataclass +class RogueTournRenameArchiveCsReq(betterproto.Message): + max_times: int = betterproto.uint32_field(10) + name: str = betterproto.string_field(2) + + +@dataclass +class RogueTournRenameArchiveScRsp(betterproto.Message): + max_times: int = betterproto.uint32_field(11) + retcode: int = betterproto.uint32_field(3) + name: str = betterproto.string_field(15) + + +@dataclass +class RogueTournClearArchiveNameScNotify(betterproto.Message): + max_times: int = betterproto.uint32_field(10) + + +@dataclass +class OOMGHIBBCBN(betterproto.Message): + jncbpdhcahi: List[int] = betterproto.uint32_field(13) + mkaifjibjik: List[int] = betterproto.uint32_field(11) + hgcgilabndl: List["BMPCJDEAIIH"] = betterproto.message_field(10) + hmjfcdlcifd: List[int] = betterproto.uint32_field(6) + sub_tourn_id: int = betterproto.uint32_field(7) + amldailbmbo: List[int] = betterproto.uint32_field(15) + main_tourn_id: int = betterproto.uint32_field(1) + + +@dataclass +class BMPCJDEAIIH(betterproto.Message): + bijgjecjmhm: List[int] = betterproto.uint32_field(10) + avatar_id: int = betterproto.uint32_field(8) + ofikkogklgo: int = betterproto.uint32_field(2) + fclolobfpal: int = betterproto.uint32_field(4) + max_times: int = betterproto.uint32_field(3) + + +@dataclass +class ABDABIIKOJC(betterproto.Message): + gndiodgogpi: "OOMGHIBBCBN" = betterproto.message_field(1) + name: str = betterproto.string_field(14) + time: int = betterproto.int64_field(4) + max_times: int = betterproto.uint32_field(13) + + +@dataclass +class NEMPMKMLMPA(betterproto.Message): + pass + + +@dataclass +class PIFEBIKOBKK(betterproto.Message): + iiccngokklf: List["ABDABIIKOJC"] = betterproto.message_field(5) + retcode: int = betterproto.uint32_field(4) + + +@dataclass +class NAFDLMKOPKI(betterproto.Message): + ndobmajmlnk: List[int] = betterproto.uint32_field(5) + + +@dataclass +class IMJLMLGPDKN(betterproto.Message): + ndobmajmlnk: List[int] = betterproto.uint32_field(3) + retcode: int = betterproto.uint32_field(5) + + +@dataclass +class HCKHBFLLEPL(betterproto.Message): + max_times: int = betterproto.uint32_field(13) + name: str = betterproto.string_field(1) + gndiodgogpi: "OOMGHIBBCBN" = betterproto.message_field(3) + + +@dataclass +class BKHCDHKLADH(betterproto.Message): + retcode: int = betterproto.uint32_field(10) + name: str = betterproto.string_field(2) + max_times: int = betterproto.uint32_field(11) + + +@dataclass +class EGHMOPNDPPB(betterproto.Message): + max_times: int = betterproto.uint32_field(5) + name: str = betterproto.string_field(10) + + +@dataclass +class DJICLHILEPO(betterproto.Message): + retcode: int = betterproto.uint32_field(9) + max_times: int = betterproto.uint32_field(10) + name: str = betterproto.string_field(15) + + +@dataclass +class RogueTournGetPermanentTalentInfoCsReq(betterproto.Message): + pass + + +@dataclass +class RogueTournGetPermanentTalentInfoScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(4) + permanent_info: "RogueTournPermanentTalentInfo" = betterproto.message_field(13) + + +@dataclass +class RogueTournEnablePermanentTalentCsReq(betterproto.Message): + talent_id: int = betterproto.uint32_field(13) + + +@dataclass +class RogueTournEnablePermanentTalentScRsp(betterproto.Message): + permanent_info: "RogueTournPermanentTalentInfo" = betterproto.message_field(5) + retcode: int = betterproto.uint32_field(6) + + +@dataclass +class RogueTournResetPermanentTalentCsReq(betterproto.Message): + pass + + +@dataclass +class RogueTournResetPermanentTalentScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(8) + permanent_info: "RogueTournPermanentTalentInfo" = betterproto.message_field(3) + + +@dataclass +class RogueTournEnterRogueCocoonSceneCsReq(betterproto.Message): + pilmkhckmed: int = betterproto.uint32_field(7) + ibgnlboebcg: int = betterproto.uint32_field(3) + eiddmghlpbp: bool = betterproto.bool_field(15) + difficulty_level: int = betterproto.uint32_field(9) + avatar_list: List["PHHKOMBGPPK"] = betterproto.message_field(5) + + +@dataclass +class RogueTournEnterRogueCocoonSceneScRsp(betterproto.Message): + rogue_tourn_cur_scene_info: "RogueTournCurSceneInfo" = betterproto.message_field(15) + retcode: int = betterproto.uint32_field(2) + + +@dataclass +class RogueTournLeaveRogueCocoonSceneCsReq(betterproto.Message): + pass + + +@dataclass +class RogueTournLeaveRogueCocoonSceneScRsp(betterproto.Message): + rogue_tourn_cur_scene_info: "RogueTournCurSceneInfo" = betterproto.message_field(15) + retcode: int = betterproto.uint32_field(10) + + +@dataclass +class RogueTournReEnterRogueCocoonStageCsReq(betterproto.Message): + eiddmghlpbp: bool = betterproto.bool_field(8) + + +@dataclass +class RogueTournReEnterRogueCocoonStageScRsp(betterproto.Message): + battle_info: "SceneBattleInfo" = betterproto.message_field(1) + retcode: int = betterproto.uint32_field(2) + + +@dataclass +class RogueTournGetCurRogueCocoonInfoCsReq(betterproto.Message): + pass + + +@dataclass +class RogueTournGetCurRogueCocoonInfoScRsp(betterproto.Message): + pilmkhckmed: int = betterproto.uint32_field(15) + ibgnlboebcg: int = betterproto.uint32_field(2) + retcode: int = betterproto.uint32_field(8) + difficulty_level: int = betterproto.uint32_field(1) + + +@dataclass +class RogueTournDifficultyCompNotify(betterproto.Message): + gggfigcpklf: List[int] = betterproto.uint32_field(11) + + +@dataclass +class JNIAOGIIOGB(betterproto.Message): + miracle_id: int = betterproto.uint32_field(9) + + +@dataclass +class JCCCACNFDJG(betterproto.Message): + miracle_id: int = betterproto.uint32_field(11) + + +@dataclass +class JFIHGDPOIID(betterproto.Message): + buff_id: int = betterproto.uint32_field(11) + + +@dataclass +class ECGOCHPMCPD(betterproto.Message): + event_id: int = betterproto.uint32_field(14) + + +@dataclass +class APFJLOFINFJ(betterproto.Message): + formula_id: int = betterproto.uint32_field(15) + + +@dataclass +class FIDFNNCJAJE(betterproto.Message): + ijppknknlnl: int = betterproto.uint32_field(2) + dchpogobdko: int = betterproto.uint32_field(5) + level: int = betterproto.uint32_field(11) + iboekjbomog: int = betterproto.uint32_field(14) + + +@dataclass +class RogueTournHandBookNotify(betterproto.Message): + iihopmeeaja: "JNIAOGIIOGB" = betterproto.message_field(11) + gpolbdgoood: "JCCCACNFDJG" = betterproto.message_field(10) + buff: "JFIHGDPOIID" = betterproto.message_field(5) + nfldodiabcl: "ECGOCHPMCPD" = betterproto.message_field(3) + tourn_formula_info: "APFJLOFINFJ" = betterproto.message_field(9) + jmidlldkjbi: "FIDFNNCJAJE" = betterproto.message_field(13) + + +@dataclass +class RogueTournGetSettleInfoCsReq(betterproto.Message): + area_id: int = betterproto.uint32_field(1) + + +@dataclass +class RogueTournGetSettleInfoScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(3) + tourn_finish_info: "RogueTournFinishInfo" = betterproto.message_field(7) + + +@dataclass +class RogueTournConfirmSettleCsReq(betterproto.Message): + name: str = betterproto.string_field(9) + area_id: int = betterproto.uint32_field(6) + max_times: int = betterproto.uint32_field(15) + + +@dataclass +class RogueTournConfirmSettleScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(1) + rogue_tourn_cur_scene_info: "RogueTournCurSceneInfo" = betterproto.message_field(15) + ohhjkgfofhb: "RogueTournSaveList" = betterproto.message_field(3) + gfonfdbfbna: "ItemList" = betterproto.message_field(10) + jplaapjccbh: "ItemList" = betterproto.message_field(12) + + +@dataclass +class RogueTournWeekChallengeUpdateScNotify(betterproto.Message): + extra_score_info: "ExtraScoreInfo" = betterproto.message_field(14) + + +@dataclass +class RogueTournGetMiscRealTimeDataCsReq(betterproto.Message): + pass + + +@dataclass +class RogueTournGetMiscRealTimeDataScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(1) + gcglnkfdkkn: "NNIJCDKHPKL" = betterproto.message_field(2) + cjcojamleel: "NKPKIAAMODG" = betterproto.message_field(6) + kgciaiafibe: "GPNJMEHNDMN" = betterproto.message_field(12) + clkhpondddo: "KCLCHJMNPGL" = betterproto.message_field(10) + pfoepfphfnj: "FBHNFJCNHML" = betterproto.message_field(8) + + +@dataclass +class RogueTournGetArchiveRepositoryCsReq(betterproto.Message): + pass + + +@dataclass +class RogueTournGetArchiveRepositoryScRsp(betterproto.Message): + hkdoclopkoh: List[int] = betterproto.uint32_field(10) + lnejmjbfllh: List[int] = betterproto.uint32_field(14) + retcode: int = betterproto.uint32_field(7) + + +@dataclass +class RogueTournReviveCostUpdateScNotify(betterproto.Message): + rogue_revive_cost: "ItemCostData" = betterproto.message_field(3) + + +@dataclass +class RogueTournReviveAvatarCsReq(betterproto.Message): + interacted_prop_entity_id: int = betterproto.uint32_field(5) + base_avatar_id_list: List[int] = betterproto.uint32_field(14) + + +@dataclass +class RogueTournReviveAvatarScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(1) + rogue_revive_cost: "ItemCostData" = betterproto.message_field(10) + + +@dataclass +class RogueTournBattleFailSettleInfoScNotify(betterproto.Message): + rogue_tourn_cur_scene_info: "RogueTournCurSceneInfo" = betterproto.message_field(12) + tourn_finish_info: "RogueTournFinishInfo" = betterproto.message_field(7) + + +@dataclass +class GIGPOFFBIEO(betterproto.Message): + talent_info_list: "RogueTalentInfoList" = betterproto.message_field(5) + cmoghiandfl: int = betterproto.uint32_field(6) + + +@dataclass +class RogueTournGetSeasonTalentInfoCsReq(betterproto.Message): + pass + + +@dataclass +class RogueTournGetSeasonTalentInfoScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(15) + llaoogchhdk: "GIGPOFFBIEO" = betterproto.message_field(8) + + +@dataclass +class RogueTournEnableSeasonTalentCsReq(betterproto.Message): + talent_id: int = betterproto.uint32_field(12) + + +@dataclass +class RogueTournEnableSeasonTalentScRsp(betterproto.Message): + llaoogchhdk: "GIGPOFFBIEO" = betterproto.message_field(9) + retcode: int = betterproto.uint32_field(5) + + +@dataclass +class RogueTournTitanUpdateTitanBlessProgressScNotify(betterproto.Message): + ldfgifdfpcf: int = betterproto.uint32_field(15) + + +@dataclass +class GetRollShopInfoCsReq(betterproto.Message): + roll_shop_id: int = betterproto.uint32_field(14) + + +@dataclass +class GetRollShopInfoScRsp(betterproto.Message): + gacha_random: int = betterproto.uint32_field(12) + shop_group_id_list: List[int] = betterproto.uint32_field(13) + retcode: int = betterproto.uint32_field(5) + roll_shop_id: int = betterproto.uint32_field(15) + + +@dataclass +class DoGachaInRollShopCsReq(betterproto.Message): + gacha_count: int = betterproto.uint32_field(3) + gacha_random: int = betterproto.uint32_field(4) + roll_shop_id: int = betterproto.uint32_field(11) + + +@dataclass +class DoGachaInRollShopScRsp(betterproto.Message): + roll_shop_id: int = betterproto.uint32_field(4) + retcode: int = betterproto.uint32_field(11) + penilhglhhm: int = betterproto.uint32_field(13) + reward_display_type: int = betterproto.uint32_field(3) + reward: "ItemList" = betterproto.message_field(9) + + +@dataclass +class TakeRollShopRewardCsReq(betterproto.Message): + roll_shop_id: int = betterproto.uint32_field(9) + + +@dataclass +class TakeRollShopRewardScRsp(betterproto.Message): + roll_shop_id: int = betterproto.uint32_field(9) + reward: "ItemList" = betterproto.message_field(4) + retcode: int = betterproto.uint32_field(12) + group_type: int = betterproto.uint32_field(8) + + +@dataclass +class SceneActorInfo(betterproto.Message): + uid: int = betterproto.uint32_field(11) + map_layer: int = betterproto.uint32_field(15) + base_avatar_id: int = betterproto.uint32_field(12) + avatar_type: "AvatarType" = betterproto.enum_field(9) + + +@dataclass +class NpcMonsterRogueInfo(betterproto.Message): + rogue_monster_id: int = betterproto.uint32_field(13) + elite_group: int = betterproto.uint32_field(1) + hard_level_group: int = betterproto.uint32_field(9) + dneampllfme: int = betterproto.uint32_field(3) + level: int = betterproto.uint32_field(12) + + +@dataclass +class NpcMonsterExtraInfo(betterproto.Message): + rogue_game_info: "NpcMonsterRogueInfo" = betterproto.message_field( + 3 + ) + + +@dataclass +class SceneNpcMonsterInfo(betterproto.Message): + monster_id: int = betterproto.uint32_field(3) + event_id: int = betterproto.uint32_field(12) + mpfedfbkkdf: bool = betterproto.bool_field(13) + world_level: int = betterproto.uint32_field(7) + extra_info: "NpcMonsterExtraInfo" = betterproto.message_field(6) + idpjidnlehh: bool = betterproto.bool_field(15) + + +@dataclass +class NpcDialogueEventParam(betterproto.Message): + rogue_dialogue_event_id: int = betterproto.uint32_field(9) + arg_id: int = betterproto.uint32_field(6) + + +@dataclass +class NpcRogueGameInfo(betterproto.Message): + event_unique_id: int = betterproto.uint32_field(5) + talk_dialogue_id: int = betterproto.uint32_field(2) + lomilomcaom: bool = betterproto.bool_field(11) + kjcbneindhl: Dict[int, int] = betterproto.map_field( + 4, betterproto.TYPE_UINT32, betterproto.TYPE_UINT32 + ) + aeon_talk_id: int = betterproto.uint32_field(1) + finish_dialogue: bool = betterproto.bool_field(7) + jenfhombkke: bool = betterproto.bool_field(6) + + +@dataclass +class KKFKKPPLDAI(betterproto.Message): + is_meet: bool = betterproto.bool_field(13) + amlkpohdeln: int = betterproto.uint32_field(7) + visitor_id: int = betterproto.uint32_field(14) + + +@dataclass +class CLFACBCGIFL(betterproto.Message): + klfcnoaggpc: int = betterproto.uint32_field(1) + incagnldjmn: int = betterproto.uint32_field(9) + + +@dataclass +class NpcExtraInfo(betterproto.Message): + rogue_game_info: "NpcRogueGameInfo" = betterproto.message_field( + 11 + ) + jkjopmefcbo: "KKFKKPPLDAI" = betterproto.message_field(7) + pnbjjbjnmgl: "CLFACBCGIFL" = betterproto.message_field(5) + + +@dataclass +class SceneNpcInfo(betterproto.Message): + npc_id: int = betterproto.uint32_field(12) + extra_info: "NpcExtraInfo" = betterproto.message_field(6) + + +@dataclass +class PropRogueInfo(betterproto.Message): + room_id: int = betterproto.uint32_field(9) + site_id: int = betterproto.uint32_field(13) + bbnfiifmgak: int = betterproto.uint32_field(15) + ccdepapjnko: int = betterproto.uint32_field(6) + + +@dataclass +class PropAeonInfo(betterproto.Message): + dialogue_group_id: int = betterproto.uint32_field(2) + add_exp: int = betterproto.uint32_field(4) + aeon_id: int = betterproto.uint32_field(10) + + +@dataclass +class PropChessRogueInfo(betterproto.Message): + enter_next_cell: bool = betterproto.bool_field(3) + akcghbfgbcc: bool = betterproto.bool_field(13) + + +@dataclass +class RogueTournDoorInfo(betterproto.Message): + rogue_door_next_room_type: int = betterproto.uint32_field(8) + enter_next_layer: bool = betterproto.bool_field(2) + eipnnejnnkj: int = betterproto.uint32_field(13) + + +@dataclass +class RogueMagicDoorInfo(betterproto.Message): + enter_next_layer: bool = betterproto.bool_field(8) + rogue_door_next_room_type: int = betterproto.uint32_field(10) + eipnnejnnkj: int = betterproto.uint32_field(7) + + +@dataclass +class WorkbenchFuncIdInfo(betterproto.Message): + is_valid: bool = betterproto.bool_field(6) + func_id: int = betterproto.uint32_field(14) + + +@dataclass +class RogueTournWorkbenchInfo(betterproto.Message): + workbench_func_list: List["WorkbenchFuncIdInfo"] = betterproto.message_field(5) + workbench_id: int = betterproto.uint32_field(4) + + +@dataclass +class RogueGambleMachineInfo(betterproto.Message): + gamble_info: "RogueGambleInfo" = betterproto.message_field(12) + mgdmhlgjhoc: int = betterproto.uint32_field(11) + + +@dataclass +class RogueCurseChestInfo(betterproto.Message): + chest_id: int = betterproto.uint32_field(5) + + +@dataclass +class PropTimelineInfo(betterproto.Message): + timeline_bool_value: bool = betterproto.bool_field(9) + timeline_byte_value: bytes = betterproto.bytes_field(6) + + +@dataclass +class PropExtraInfo(betterproto.Message): + rogue_info: "PropRogueInfo" = betterproto.message_field(5) + aeon_info: "PropAeonInfo" = betterproto.message_field(11) + chess_rogue_info: "PropChessRogueInfo" = betterproto.message_field( + 6 + ) + rogue_tourn_door_info: "RogueTournDoorInfo" = betterproto.message_field( + 7 + ) + rogue_tourn_workbench_info: "RogueTournWorkbenchInfo" = betterproto.message_field( + 3 + ) + rogue_gamble_machine_info: "RogueGambleMachineInfo" = betterproto.message_field( + 10 + ) + rogue_curse_chest_info: "RogueCurseChestInfo" = betterproto.message_field( + 14 + ) + rogue_magic_door_info: "RogueMagicDoorInfo" = betterproto.message_field( + 12 + ) + timeline_info: "PropTimelineInfo" = betterproto.message_field(9) + + +@dataclass +class ScenePropInfo(betterproto.Message): + life_time_ms: int = betterproto.uint32_field(1) + prop_state: int = betterproto.uint32_field(14) + extra_info: "PropExtraInfo" = betterproto.message_field(13) + create_time_ms: int = betterproto.uint64_field(6) + trigger_name_list: List[str] = betterproto.string_field(4) + prop_id: int = betterproto.uint32_field(3) + + +@dataclass +class SceneSummonUnitInfo(betterproto.Message): + create_time_ms: int = betterproto.uint64_field(13) + summon_unit_id: int = betterproto.uint32_field(15) + attach_entity_id: int = betterproto.uint32_field(2) + life_time_ms: int = betterproto.int32_field(7) + caster_entity_id: int = betterproto.uint32_field(5) + trigger_name_list: List[str] = betterproto.string_field(4) + + +@dataclass +class SceneEntityInfo(betterproto.Message): + actor: "SceneActorInfo" = betterproto.message_field(6) + npc_monster: "SceneNpcMonsterInfo" = betterproto.message_field( + 4 + ) + npc: "SceneNpcInfo" = betterproto.message_field(12) + prop: "ScenePropInfo" = betterproto.message_field(5) + summon_unit: "SceneSummonUnitInfo" = betterproto.message_field( + 7 + ) + motion: "MotionInfo" = betterproto.message_field(9) + group_id: int = betterproto.uint32_field(15) + inst_id: int = betterproto.uint32_field(8) + entity_id: int = betterproto.uint32_field(2) + + +@dataclass +class BuffInfo(betterproto.Message): + level: int = betterproto.uint32_field(5) + buff_id: int = betterproto.uint32_field(11) + count: int = betterproto.uint32_field(6) + buff_summon_entity_id: int = betterproto.uint32_field(8) + dynamic_values: Dict[str, float] = betterproto.map_field( + 1, betterproto.TYPE_STRING, betterproto.TYPE_FLOAT + ) + base_avatar_id: int = betterproto.uint32_field(3) + life_time: float = betterproto.float_field(9) + add_time_ms: int = betterproto.uint64_field(2) + + +@dataclass +class EntityBuffInfo(betterproto.Message): + entity_id: int = betterproto.uint32_field(14) + buff_list: List["BuffInfo"] = betterproto.message_field(15) + + +@dataclass +class MechanismBarInfo(betterproto.Message): + value: int = betterproto.uint32_field(3) + ohdeoighiem: int = betterproto.uint32_field(2) + + +@dataclass +class CustomSaveData(betterproto.Message): + group_id: int = betterproto.uint32_field(3) + save_data: str = betterproto.string_field(9) + + +@dataclass +class KEGMIHDFPMM(betterproto.Message): + blogjdckahm: int = betterproto.uint32_field(14) + cppdjfkiihk: int = betterproto.uint32_field(6) + + +@dataclass +class SceneEntityGroupInfo(betterproto.Message): + state: int = betterproto.uint32_field(6) + group_id: int = betterproto.uint32_field(9) + entity_list: List["SceneEntityInfo"] = betterproto.message_field(12) + hejamoojbcj: Dict[str, int] = betterproto.map_field( + 3, betterproto.TYPE_STRING, betterproto.TYPE_INT32 + ) + + +@dataclass +class SceneGroupState(betterproto.Message): + state: int = betterproto.uint32_field(12) + is_default: bool = betterproto.bool_field(4) + group_id: int = betterproto.uint32_field(3) + + +@dataclass +class MissionStatusBySceneInfo(betterproto.Message): + disabled_main_mission_id_list: List[int] = betterproto.uint32_field(8) + unfinished_main_mission_id_list: List[int] = betterproto.uint32_field(11) + finished_main_mission_id_list: List[int] = betterproto.uint32_field(6) + bigehkdpgpn: List["MainMissionCustomValue"] = betterproto.message_field(14) + sub_mission_status_list: List["Mission"] = betterproto.message_field(13) + + +@dataclass +class SceneInfo(betterproto.Message): + floor_saved_data: Dict[str, int] = betterproto.map_field( + 1560, betterproto.TYPE_STRING, betterproto.TYPE_INT32 + ) + entity_buff_info_list: List["EntityBuffInfo"] = betterproto.message_field(11) + custom_data_list: List["CustomSaveData"] = betterproto.message_field(9) + world_id: int = betterproto.uint32_field(7) + entry_id: int = betterproto.uint32_field(8) + game_mode_type: int = betterproto.uint32_field(2) + scene_buff_info_list: List["BuffInfo"] = betterproto.message_field(5) + content_id: int = betterproto.uint32_field(1168) + floor_id: int = betterproto.uint32_field(6) + game_story_line_id: int = betterproto.uint32_field(1925) + client_pos_version: int = betterproto.uint32_field(3) + djbibijmebh: List[int] = betterproto.uint32_field(624) + entity_list: List["SceneEntityInfo"] = betterproto.message_field(15) + entity_group_list: List["SceneEntityGroupInfo"] = betterproto.message_field(351) + leader_entity_id: int = betterproto.uint32_field(4) + dimension_id: int = betterproto.uint32_field(1384) + scene_mission_info: "MissionStatusBySceneInfo" = betterproto.message_field(976) + mpehibkeobe: Dict[int, "KEGMIHDFPMM"] = betterproto.map_field( + 10, betterproto.TYPE_UINT32, betterproto.TYPE_MESSAGE + ) + plane_id: int = betterproto.uint32_field(14) + lighten_section_list: List[int] = betterproto.uint32_field(13) + group_state_list: List["SceneGroupState"] = betterproto.message_field(524) + + +@dataclass +class EntityMotion(betterproto.Message): + entity_id: int = betterproto.uint32_field(12) + map_layer: int = betterproto.uint32_field(10) + motion: "MotionInfo" = betterproto.message_field(13) + nfopikdkpgg: bool = betterproto.bool_field(1) + + +@dataclass +class SceneEntityMoveCsReq(betterproto.Message): + entry_id: int = betterproto.uint32_field(14) + entity_motion_list: List["EntityMotion"] = betterproto.message_field(15) + pemlejjbaje: int = betterproto.uint64_field(6) + + +@dataclass +class SceneEntityMoveScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(4) + entity_motion_list: List["EntityMotion"] = betterproto.message_field(15) + download_data: "ClientDownloadData" = betterproto.message_field(2) + + +@dataclass +class SceneEntityMoveScNotify(betterproto.Message): + motion: "MotionInfo" = betterproto.message_field(5) + client_pos_version: int = betterproto.uint32_field(2) + entry_id: int = betterproto.uint32_field(6) + entity_id: int = betterproto.uint32_field(14) + + +@dataclass +class SceneUpdatePositionVersionNotify(betterproto.Message): + pos_version: int = betterproto.uint32_field(9) + + +@dataclass +class InteractPropCsReq(betterproto.Message): + prop_entity_id: int = betterproto.uint32_field(13) + interact_id: int = betterproto.uint32_field(10) + + +@dataclass +class InteractPropScRsp(betterproto.Message): + prop_state: int = betterproto.uint32_field(2) + prop_entity_id: int = betterproto.uint32_field(12) + retcode: int = betterproto.uint32_field(13) + + +@dataclass +class ChangePropTimelineInfoCsReq(betterproto.Message): + uuid: int = betterproto.uint64_field(9) + timeline_info: "PropTimelineInfo" = betterproto.message_field(11) + is_close_map: bool = betterproto.bool_field(2) + prop_entity_id: int = betterproto.uint32_field(8) + + +@dataclass +class ChangePropTimelineInfoScRsp(betterproto.Message): + prop_entity_id: int = betterproto.uint32_field(10) + retcode: int = betterproto.uint32_field(14) + + +@dataclass +class HitMonsterBattleInfo(betterproto.Message): + monster_battle_type: "MonsterBattleType" = betterproto.enum_field(9) + target_monster_entity_id: int = betterproto.uint32_field(7) + + +@dataclass +class DynamicValues(betterproto.Message): + key: str = betterproto.string_field(3) + value: float = betterproto.float_field(10) + + +@dataclass +class AssistMonsterEntityInfo(betterproto.Message): + entity_id_list: List[int] = betterproto.uint32_field(11) + + +@dataclass +class SceneCastSkillCsReq(betterproto.Message): + attacked_by_entity_id: int = betterproto.uint32_field(11) + cast_entity_id: int = betterproto.uint32_field(14) + hit_target_entity_id_list: List[int] = betterproto.uint32_field(4) + assist_monster_entity_id_list: List[int] = betterproto.uint32_field(8) + skill_extra_tags: List["SkillExtraTag"] = betterproto.enum_field(5) + hchdhljcije: int = betterproto.uint32_field(1) + skill_index: int = betterproto.uint32_field(10) + target_motion: "MotionInfo" = betterproto.message_field(13) + assist_monster_entity_info: List["AssistMonsterEntityInfo"] = ( + betterproto.message_field(6) + ) + dynamic_values: List["DynamicValues"] = betterproto.message_field(7) + maze_ability_str: str = betterproto.string_field(3) + + +@dataclass +class SceneCastSkillScRsp(betterproto.Message): + monster_battle_info: List["HitMonsterBattleInfo"] = betterproto.message_field(9) + retcode: int = betterproto.uint32_field(3) + cast_entity_id: int = betterproto.uint32_field(8) + battle_info: "SceneBattleInfo" = betterproto.message_field(11) + + +@dataclass +class SceneCastSkillCostMpCsReq(betterproto.Message): + skill_index: int = betterproto.uint32_field(8) + attacked_by_entity_id: int = betterproto.uint32_field(5) + cast_entity_id: int = betterproto.uint32_field(10) + + +@dataclass +class SceneCastSkillCostMpScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(14) + cast_entity_id: int = betterproto.uint32_field(5) + + +@dataclass +class SceneCastSkillMpUpdateScNotify(betterproto.Message): + mp: int = betterproto.uint32_field(5) + cast_entity_id: int = betterproto.uint32_field(10) + + +@dataclass +class SceneEnterStageCsReq(betterproto.Message): + rebattle_type: "RebattleType" = betterproto.enum_field(4) + pmjahilblfl: bool = betterproto.bool_field(13) + event_id: int = betterproto.uint32_field(3) + + +@dataclass +class SceneEnterStageScRsp(betterproto.Message): + battle_info: "SceneBattleInfo" = betterproto.message_field(2) + retcode: int = betterproto.uint32_field(15) + + +@dataclass +class SceneReviveAfterRebattleCsReq(betterproto.Message): + rebattle_type: "RebattleType" = betterproto.enum_field(12) + + +@dataclass +class SceneReviveAfterRebattleScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(2) + + +@dataclass +class GetCurSceneInfoCsReq(betterproto.Message): + pass + + +@dataclass +class GetCurSceneInfoScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(11) + scene: "SceneInfo" = betterproto.message_field(9) + + +@dataclass +class EntityBuffChangeInfo(betterproto.Message): + buff_change_info: "BuffInfo" = betterproto.message_field(6) + remove_buff_id: int = betterproto.uint32_field(2) + cast_entity_id: int = betterproto.uint32_field(15) + entity_id: int = betterproto.uint32_field(12) + reason: "SceneEntityBuffChangeType" = betterproto.enum_field(7) + + +@dataclass +class SyncEntityBuffChangeListScNotify(betterproto.Message): + entity_buff_change_list: List["EntityBuffChangeInfo"] = betterproto.message_field(3) + + +@dataclass +class SpringRefreshCsReq(betterproto.Message): + floor_id: int = betterproto.uint32_field(13) + plane_id: int = betterproto.uint32_field(9) + prop_entity_id: int = betterproto.uint32_field(5) + + +@dataclass +class SpringRefreshScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(10) + + +@dataclass +class LastSpringRefreshTimeNotify(betterproto.Message): + jbicindpigm: int = betterproto.int64_field(3) + + +@dataclass +class ReturnLastTownCsReq(betterproto.Message): + pass + + +@dataclass +class ReturnLastTownScRsp(betterproto.Message): + scene: "SceneInfo" = betterproto.message_field(15) + retcode: int = betterproto.uint32_field(12) + + +@dataclass +class EnterSectionCsReq(betterproto.Message): + section_id: int = betterproto.uint32_field(7) + + +@dataclass +class EnterSectionScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(11) + + +@dataclass +class SetCurInteractEntityCsReq(betterproto.Message): + entity_id: int = betterproto.uint32_field(14) + + +@dataclass +class SetCurInteractEntityScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(2) + + +@dataclass +class RecoverAllLineupCsReq(betterproto.Message): + pass + + +@dataclass +class RecoverAllLineupScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(12) + + +@dataclass +class SavePointsInfoNotify(betterproto.Message): + valid_times: int = betterproto.uint32_field(3) + refresh_time: int = betterproto.int64_field(10) + + +@dataclass +class StartCocoonStageCsReq(betterproto.Message): + cocoon_id: int = betterproto.uint32_field(9) + wave: int = betterproto.uint32_field(14) + prop_entity_id: int = betterproto.uint32_field(4) + world_level: int = betterproto.uint32_field(6) + + +@dataclass +class StartCocoonStageScRsp(betterproto.Message): + prop_entity_id: int = betterproto.uint32_field(14) + cocoon_id: int = betterproto.uint32_field(6) + retcode: int = betterproto.uint32_field(13) + wave: int = betterproto.uint32_field(3) + battle_info: "SceneBattleInfo" = betterproto.message_field(8) + + +@dataclass +class EntityBindPropCsReq(betterproto.Message): + motion: "MotionInfo" = betterproto.message_field(11) + mjjmpiflmkf: bool = betterproto.bool_field(10) + + +@dataclass +class EntityBindPropScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(9) + + +@dataclass +class SetClientPausedCsReq(betterproto.Message): + paused: bool = betterproto.bool_field(1) + + +@dataclass +class SetClientPausedScRsp(betterproto.Message): + paused: bool = betterproto.bool_field(9) + retcode: int = betterproto.uint32_field(10) + + +@dataclass +class DeactivateFarmElementCsReq(betterproto.Message): + entity_id: int = betterproto.uint32_field(13) + + +@dataclass +class DeactivateFarmElementScRsp(betterproto.Message): + entity_id: int = betterproto.uint32_field(13) + retcode: int = betterproto.uint32_field(12) + + +@dataclass +class ActivateFarmElementCsReq(betterproto.Message): + entity_id: int = betterproto.uint32_field(5) + world_level: int = betterproto.uint32_field(13) + + +@dataclass +class ActivateFarmElementScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(7) + entity_id: int = betterproto.uint32_field(4) + world_level: int = betterproto.uint32_field(3) + + +@dataclass +class AvatarPresetHp(betterproto.Message): + jlafldchdgj: int = betterproto.uint32_field(1) + avatar_id: int = betterproto.uint32_field(8) + + +@dataclass +class SpringRecoverConfig(betterproto.Message): + bcglmlabogf: List["AvatarPresetHp"] = betterproto.message_field(1) + eidnigifnaa: int = betterproto.uint32_field(9) + ghdepancgpf: bool = betterproto.bool_field(15) + + +@dataclass +class UpdateMechanismBarScNotify(betterproto.Message): + floor_id: int = betterproto.uint32_field(3) + gigkdapgnme: "MechanismBarInfo" = betterproto.message_field(8) + plane_id: int = betterproto.uint32_field(5) + + +@dataclass +class SetGroupCustomSaveDataCsReq(betterproto.Message): + save_data: str = betterproto.string_field(7) + entry_id: int = betterproto.uint32_field(12) + group_id: int = betterproto.uint32_field(11) + + +@dataclass +class SetGroupCustomSaveDataScRsp(betterproto.Message): + group_id: int = betterproto.uint32_field(15) + entry_id: int = betterproto.uint32_field(13) + retcode: int = betterproto.uint32_field(11) + + +@dataclass +class ReEnterLastElementStageCsReq(betterproto.Message): + stage_id: int = betterproto.uint32_field(12) + + +@dataclass +class ReEnterLastElementStageScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(13) + stage_id: int = betterproto.uint32_field(8) + battle_info: "SceneBattleInfo" = betterproto.message_field(10) + + +@dataclass +class SceneEntityTeleportCsReq(betterproto.Message): + entry_id: int = betterproto.uint32_field(3) + entity_motion: "EntityMotion" = betterproto.message_field(8) + + +@dataclass +class SceneEntityTeleportScRsp(betterproto.Message): + client_pos_version: int = betterproto.uint32_field(4) + entity_motion: "EntityMotion" = betterproto.message_field(3) + retcode: int = betterproto.uint32_field(12) + + +@dataclass +class EnterSceneCsReq(betterproto.Message): + game_story_line_id: int = betterproto.uint32_field(4) + entry_id: int = betterproto.uint32_field(6) + teleport_id: int = betterproto.uint32_field(1) + content_id: int = betterproto.uint32_field(7) + is_close_map: bool = betterproto.bool_field(10) + + +@dataclass +class EnterSceneScRsp(betterproto.Message): + is_close_map: bool = betterproto.bool_field(1) + is_over_map: bool = betterproto.bool_field(10) + content_id: int = betterproto.uint32_field(15) + retcode: int = betterproto.uint32_field(9) + game_story_line_id: int = betterproto.uint32_field(7) + + +@dataclass +class EnterSceneByServerScNotify(betterproto.Message): + scene: "SceneInfo" = betterproto.message_field(2) + lineup: "LineupInfo" = betterproto.message_field(9) + reason: "EnterSceneReason" = betterproto.enum_field(15) + + +@dataclass +class ScenePlaneEventScNotify(betterproto.Message): + epojghebpkc: "ItemList" = betterproto.message_field(11) + get_item_list: "ItemList" = betterproto.message_field(7) + mhdjadhndkd: "ItemList" = betterproto.message_field(13) + meekfpcobai: "ItemList" = betterproto.message_field(2) + + +@dataclass +class GetSceneMapInfoCsReq(betterproto.Message): + entry_story_line_id: int = betterproto.uint32_field(1) + content_id: int = betterproto.uint32_field(9) + igfikghllno: bool = betterproto.bool_field(7) + entry_id_list: List[int] = betterproto.uint32_field(15) + floor_id_list: List[int] = betterproto.uint32_field(5) + + +@dataclass +class MazePropState(betterproto.Message): + group_id: int = betterproto.uint32_field(12) + config_id: int = betterproto.uint32_field(11) + state: int = betterproto.uint32_field(6) + + +@dataclass +class OFCAIGDHPOH(betterproto.Message): + state: int = betterproto.uint32_field(5) + group_id: int = betterproto.uint32_field(7) + extra_info: "PropExtraInfo" = betterproto.message_field(1) + config_id: int = betterproto.uint32_field(3) + + +@dataclass +class MazeGroup(betterproto.Message): + group_id: int = betterproto.uint32_field(5) + ilbeaaoojjp: bool = betterproto.bool_field(1) + nobkeonakle: List[int] = betterproto.uint32_field(12) + inldcclioan: int = betterproto.int64_field(4) + + +@dataclass +class ChestInfo(betterproto.Message): + chest_type: "ChestType" = betterproto.enum_field(8) + exist_num: int = betterproto.uint32_field(14) + opened_num: int = betterproto.uint32_field(1) + + +@dataclass +class NPAOGKFKAAE(betterproto.Message): + fljindnjphl: int = betterproto.uint32_field(9) + type: int = betterproto.uint32_field(10) + fokcifjmjgl: int = betterproto.uint32_field(11) + + +@dataclass +class SceneMapInfo(betterproto.Message): + chest_list: List["ChestInfo"] = betterproto.message_field(1) + lighten_section_list: List[int] = betterproto.uint32_field(11) + entry_id: int = betterproto.uint32_field(10) + floor_saved_data: Dict[str, int] = betterproto.map_field( + 15, betterproto.TYPE_STRING, betterproto.TYPE_INT32 + ) + lmngahfnaon: List["OFCAIGDHPOH"] = betterproto.message_field(6) + dimension_id: int = betterproto.uint32_field(12) + jmldmocnmhm: List["NPAOGKFKAAE"] = betterproto.message_field(7) + retcode: int = betterproto.uint32_field(9) + unlock_teleport_list: List[int] = betterproto.uint32_field(8) + cur_map_entry_id: int = betterproto.uint32_field(3) + maze_prop_list: List["MazePropState"] = betterproto.message_field(4) + floor_id: int = betterproto.uint32_field(2) + maze_group_list: List["MazeGroup"] = betterproto.message_field(5) + + +@dataclass +class GetSceneMapInfoScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(14) + content_id: int = betterproto.uint32_field(10) + igfikghllno: bool = betterproto.bool_field(1) + scene_map_info: List["SceneMapInfo"] = betterproto.message_field(12) + entry_story_line_id: int = betterproto.uint32_field(6) + + +@dataclass +class SyncServerSceneChangeNotify(betterproto.Message): + pass + + +@dataclass +class GameplayCounterCountDownCsReq(betterproto.Message): + nmglnhpanah: int = betterproto.uint32_field(6) + cur_times: int = betterproto.uint32_field(9) + + +@dataclass +class GameplayCounterCountDownScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(13) + + +@dataclass +class GameplayCounterUpdateScNotify(betterproto.Message): + blogjdckahm: int = betterproto.uint32_field(13) + reason: "GameplayCounterUpdateReason" = betterproto.enum_field(5) + nmglnhpanah: int = betterproto.uint32_field(15) + + +@dataclass +class GameplayCounterRecoverCsReq(betterproto.Message): + nmglnhpanah: int = betterproto.uint32_field(14) + labooddaloe: int = betterproto.uint32_field(8) + + +@dataclass +class GameplayCounterRecoverScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(8) + + +@dataclass +class UpdateFloorSavedValueNotify(betterproto.Message): + dimension_id: int = betterproto.uint32_field(7) + saved_value: Dict[str, int] = betterproto.map_field( + 10, betterproto.TYPE_STRING, betterproto.TYPE_INT32 + ) + floor_id: int = betterproto.uint32_field(12) + plane_id: int = betterproto.uint32_field(1) + + +@dataclass +class GetUnlockTeleportCsReq(betterproto.Message): + entry_id_list: List[int] = betterproto.uint32_field(4) + + +@dataclass +class GetUnlockTeleportScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(3) + unlock_teleport_list: List[int] = betterproto.uint32_field(13) + + +@dataclass +class OpenChestScNotify(betterproto.Message): + chest_id: int = betterproto.uint32_field(8) + + +@dataclass +class SceneEntityRefreshInfo(betterproto.Message): + add_entity: "SceneEntityInfo" = betterproto.message_field(3) + delete_entity: int = betterproto.uint32_field(9) + mhhoaahdgao: int = betterproto.uint32_field(5) + + +@dataclass +class CMGFHBHAFFB(betterproto.Message): + dlmamkinnco: int = betterproto.int32_field(8) + agfijniebkf: int = betterproto.int32_field(7) + jaibieekheg: str = betterproto.string_field(1) + + +@dataclass +class GroupRefreshInfo(betterproto.Message): + refresh_entity: List["SceneEntityRefreshInfo"] = betterproto.message_field(3) + refresh_type: "SceneGroupRefreshType" = betterproto.enum_field(14) + group_id: int = betterproto.uint32_field(9) + state: int = betterproto.uint32_field(5) + bccgjihncdn: List["CMGFHBHAFFB"] = betterproto.message_field(11) + + +@dataclass +class SceneGroupRefreshScNotify(betterproto.Message): + dimension_id: int = betterproto.uint32_field(14) + floor_id: int = betterproto.uint32_field(10) + group_refresh_list: List["GroupRefreshInfo"] = betterproto.message_field(4) + + +@dataclass +class GroupStateInfo(betterproto.Message): + group_id: int = betterproto.uint32_field(4) + entry_id: int = betterproto.uint32_field(10) + gdnopaabghf: int = betterproto.uint32_field(15) + group_state: int = betterproto.uint32_field(3) + + +@dataclass +class GroupStateChangeCsReq(betterproto.Message): + group_state_info: "GroupStateInfo" = betterproto.message_field(9) + + +@dataclass +class GroupStateChangeScRsp(betterproto.Message): + group_state_info: "GroupStateInfo" = betterproto.message_field(13) + retcode: int = betterproto.uint32_field(15) + + +@dataclass +class GroupStateChangeScNotify(betterproto.Message): + group_state_info: "GroupStateInfo" = betterproto.message_field(14) + + +@dataclass +class EnteredSceneInfo(betterproto.Message): + plane_id: int = betterproto.uint32_field(12) + floor_id: int = betterproto.uint32_field(11) + + +@dataclass +class GetEnteredSceneCsReq(betterproto.Message): + pass + + +@dataclass +class GetEnteredSceneScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(8) + entered_scene_info_list: List["EnteredSceneInfo"] = betterproto.message_field(14) + + +@dataclass +class EnteredSceneChangeScNotify(betterproto.Message): + entered_scene_info_list: List["EnteredSceneInfo"] = betterproto.message_field(2) + + +@dataclass +class RefreshTriggerByClientCsReq(betterproto.Message): + trigger_target_id_list: List[int] = betterproto.uint32_field(7) + trigger_name: str = betterproto.string_field(3) + trigger_entity_id: int = betterproto.uint32_field(14) + trigger_motion: "MotionInfo" = betterproto.message_field(2) + + +@dataclass +class RefreshTriggerByClientScRsp(betterproto.Message): + trigger_name: str = betterproto.string_field(3) + trigger_entity_id: int = betterproto.uint32_field(14) + retcode: int = betterproto.uint32_field(10) + refresh_trigger: bool = betterproto.bool_field(15) + + +@dataclass +class RefreshTriggerByClientScNotify(betterproto.Message): + trigger_name: str = betterproto.string_field(11) + trigger_target_id_list: List[int] = betterproto.uint32_field(13) + trigger_entity_id: int = betterproto.uint32_field(8) + + +@dataclass +class DeleteSummonUnitCsReq(betterproto.Message): + entity_id_list: List[int] = betterproto.uint32_field(3) + + +@dataclass +class DeleteSummonUnitScRsp(betterproto.Message): + entity_id_list: List[int] = betterproto.uint32_field(2) + retcode: int = betterproto.uint32_field(10) + + +@dataclass +class UnlockedAreaMapScNotify(betterproto.Message): + entry_id_list: List[int] = betterproto.uint32_field(4) + + +@dataclass +class UnlockTeleportNotify(betterproto.Message): + entry_id: int = betterproto.uint32_field(15) + teleport_id: int = betterproto.uint32_field(2) + + +@dataclass +class UpdateGroupPropertyCsReq(betterproto.Message): + jaibieekheg: str = betterproto.string_field(4) + dimension_id: int = betterproto.uint32_field(10) + floor_id: int = betterproto.uint32_field(7) + mojohjebcnj: int = betterproto.int32_field(2) + group_id: int = betterproto.uint32_field(11) + + +@dataclass +class UpdateGroupPropertyScRsp(betterproto.Message): + dimension_id: int = betterproto.uint32_field(2) + group_id: int = betterproto.uint32_field(6) + jaibieekheg: str = betterproto.string_field(10) + floor_id: int = betterproto.uint32_field(9) + retcode: int = betterproto.uint32_field(13) + agfijniebkf: int = betterproto.int32_field(5) + dlmamkinnco: int = betterproto.int32_field(1) + + +@dataclass +class TrainWorldIdChangeScNotify(betterproto.Message): + npebnekdlen: int = betterproto.uint32_field(15) + + +@dataclass +class ServerPrefs(betterproto.Message): + server_prefs_id: int = betterproto.uint32_field(3) + data: bytes = betterproto.bytes_field(2) + + +@dataclass +class GetAllServerPrefsDataCsReq(betterproto.Message): + pass + + +@dataclass +class GetAllServerPrefsDataScRsp(betterproto.Message): + server_prefs_list: List["ServerPrefs"] = betterproto.message_field(2) + retcode: int = betterproto.uint32_field(11) + + +@dataclass +class GetServerPrefsDataCsReq(betterproto.Message): + server_prefs_id: int = betterproto.uint32_field(9) + + +@dataclass +class GetServerPrefsDataScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(14) + server_prefs: "ServerPrefs" = betterproto.message_field(7) + + +@dataclass +class UpdateServerPrefsDataCsReq(betterproto.Message): + server_prefs: "ServerPrefs" = betterproto.message_field(10) + + +@dataclass +class UpdateServerPrefsDataScRsp(betterproto.Message): + server_prefs_id: int = betterproto.uint32_field(12) + retcode: int = betterproto.uint32_field(5) + + +@dataclass +class Shop(betterproto.Message): + city_exp: int = betterproto.uint32_field(15) + shop_id: int = betterproto.uint32_field(13) + begin_time: int = betterproto.int64_field(2) + city_level: int = betterproto.uint32_field(4) + city_taken_level_reward: int = betterproto.uint64_field(8) + end_time: int = betterproto.int64_field(5) + goods_list: List["Goods"] = betterproto.message_field(7) + + +@dataclass +class Goods(betterproto.Message): + item_id: int = betterproto.uint32_field(6) + buy_times: int = betterproto.uint32_field(13) + begin_time: int = betterproto.int64_field(12) + goods_id: int = betterproto.uint32_field(15) + end_time: int = betterproto.int64_field(5) + + +@dataclass +class GetShopListCsReq(betterproto.Message): + shop_type: int = betterproto.uint32_field(10) + + +@dataclass +class GetShopListScRsp(betterproto.Message): + shop_list: List["Shop"] = betterproto.message_field(2) + retcode: int = betterproto.uint32_field(12) + shop_type: int = betterproto.uint32_field(14) + + +@dataclass +class BuyGoodsCsReq(betterproto.Message): + interacted_prop_entity_id: int = betterproto.uint32_field(6) + fmpnheaimdn: List[int] = betterproto.uint32_field(15) + item_id: int = betterproto.uint32_field(10) + goods_id: int = betterproto.uint32_field(7) + shop_id: int = betterproto.uint32_field(9) + goods_num: int = betterproto.uint32_field(1) + + +@dataclass +class BuyGoodsScRsp(betterproto.Message): + goods_id: int = betterproto.uint32_field(15) + goods_buy_times: int = betterproto.uint32_field(10) + shop_id: int = betterproto.uint32_field(9) + retcode: int = betterproto.uint32_field(7) + return_item_list: "ItemList" = betterproto.message_field(12) + + +@dataclass +class TakeCityShopRewardCsReq(betterproto.Message): + level: int = betterproto.uint32_field(10) + shop_id: int = betterproto.uint32_field(11) + + +@dataclass +class TakeCityShopRewardScRsp(betterproto.Message): + level: int = betterproto.uint32_field(3) + shop_id: int = betterproto.uint32_field(10) + reward: "ItemList" = betterproto.message_field(5) + retcode: int = betterproto.uint32_field(12) + + +@dataclass +class CityShopInfoScNotify(betterproto.Message): + exp: int = betterproto.uint32_field(6) + taken_level_reward: int = betterproto.uint64_field(12) + level: int = betterproto.uint32_field(7) + shop_id: int = betterproto.uint32_field(5) + + +@dataclass +class FAFGMLPADMI(betterproto.Message): + item_list: List[int] = betterproto.uint32_field(7) + bejeedaebbe: int = betterproto.uint32_field(10) + unique_id: int = betterproto.uint32_field(3) + fclnoogehmc: int = betterproto.uint32_field(1) + igjcppkaibi: List[int] = betterproto.uint32_field(15) + halbhknpikh: bool = betterproto.bool_field(5) + + +@dataclass +class IPJAIINEGEL(betterproto.Message): + bejeedaebbe: int = betterproto.uint32_field(2) + ecbalmaebjc: int = betterproto.uint32_field(9) + + +@dataclass +class SpaceZooDataCsReq(betterproto.Message): + pass + + +@dataclass +class SpaceZooDataScRsp(betterproto.Message): + aagihkbfmfi: List["FAFGMLPADMI"] = betterproto.message_field(5) + kjfhkicggde: List[int] = betterproto.uint32_field(11) + bnhndbnabfn: List[int] = betterproto.uint32_field(12) + dplkbeehplb: List[int] = betterproto.uint32_field(14) + pblcahnmfjg: int = betterproto.uint32_field(2) + pmcmecdlemc: List[int] = betterproto.uint32_field(15) + inihlancnfi: List["IPJAIINEGEL"] = betterproto.message_field(4) + kmoadeogapa: List[int] = betterproto.uint32_field(3) + retcode: int = betterproto.uint32_field(10) + + +@dataclass +class SpaceZooBornCsReq(betterproto.Message): + hdcbacooind: List[int] = betterproto.uint32_field(12) + lheonphgbnb: int = betterproto.uint32_field(13) + + +@dataclass +class SpaceZooBornScRsp(betterproto.Message): + iklpncgbppc: bool = betterproto.bool_field(3) + kpkdhghdgnb: "FAFGMLPADMI" = betterproto.message_field(1) + goeaofnfjod: List["IPJAIINEGEL"] = betterproto.message_field(9) + retcode: int = betterproto.uint32_field(10) + + +@dataclass +class SpaceZooMutateCsReq(betterproto.Message): + item_id: int = betterproto.uint32_field(4) + unique_id: int = betterproto.uint32_field(6) + + +@dataclass +class SpaceZooMutateScRsp(betterproto.Message): + eflcmhmajal: "FAFGMLPADMI" = betterproto.message_field(5) + retcode: int = betterproto.uint32_field(14) + goeaofnfjod: List["IPJAIINEGEL"] = betterproto.message_field(10) + iklpncgbppc: bool = betterproto.bool_field(12) + + +@dataclass +class SpaceZooOpCatteryCsReq(betterproto.Message): + nileedjlgin: int = betterproto.uint32_field(1) + op_type: int = betterproto.uint32_field(8) + algeienioan: int = betterproto.uint32_field(3) + + +@dataclass +class SpaceZooOpCatteryScRsp(betterproto.Message): + kjfhkicggde: List[int] = betterproto.uint32_field(11) + retcode: int = betterproto.uint32_field(10) + + +@dataclass +class SpaceZooDeleteCatCsReq(betterproto.Message): + dejaooebbha: List[int] = betterproto.uint32_field(2) + + +@dataclass +class SpaceZooDeleteCatScRsp(betterproto.Message): + nfheagelici: List[int] = betterproto.uint32_field(3) + retcode: int = betterproto.uint32_field(15) + + +@dataclass +class SpaceZooCatUpdateNotify(betterproto.Message): + fpmncagjebg: bool = betterproto.bool_field(14) + iklpncgbppc: bool = betterproto.bool_field(1) + aikmbppnokd: List["FAFGMLPADMI"] = betterproto.message_field(10) + + +@dataclass +class SpaceZooExchangeItemCsReq(betterproto.Message): + item_id: int = betterproto.uint32_field(15) + + +@dataclass +class SpaceZooExchangeItemScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(1) + item_id: int = betterproto.uint32_field(14) + + +@dataclass +class SpaceZooTakeCsReq(betterproto.Message): + hlnmajidifd: int = betterproto.uint32_field(9) + + +@dataclass +class SpaceZooTakeScRsp(betterproto.Message): + hlnmajidifd: int = betterproto.uint32_field(4) + reward: "ItemList" = betterproto.message_field(5) + retcode: int = betterproto.uint32_field(3) + + +@dataclass +class MJCJAIKPLLM(betterproto.Message): + ifangmhnkbb: int = betterproto.uint32_field(7) + mpaecapoheo: int = betterproto.uint32_field(11) + group_id: int = betterproto.uint32_field(9) + acelagjphma: bool = betterproto.bool_field(10) + cbindiaamjg: int = betterproto.uint32_field(4) + + +@dataclass +class GetStarFightDataCsReq(betterproto.Message): + pass + + +@dataclass +class GetStarFightDataScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(12) + bdiimmhjlcn: List["MJCJAIKPLLM"] = betterproto.message_field(7) + + +@dataclass +class AEDAOIFFIGN(betterproto.Message): + avatar_id: int = betterproto.uint32_field(15) + avatar_type: "AvatarType" = betterproto.enum_field(8) + + +@dataclass +class StartStarFightLevelCsReq(betterproto.Message): + avatar_list: List["AEDAOIFFIGN"] = betterproto.message_field(11) + group_id: int = betterproto.uint32_field(9) + nedfibonlkb: int = betterproto.uint32_field(3) + + +@dataclass +class StartStarFightLevelScRsp(betterproto.Message): + battle_info: "SceneBattleInfo" = betterproto.message_field(6) + retcode: int = betterproto.uint32_field(5) + group_id: int = betterproto.uint32_field(10) + nedfibonlkb: int = betterproto.uint32_field(12) + + +@dataclass +class StarFightDataChangeNotify(betterproto.Message): + fmcdalalfia: "MJCJAIKPLLM" = betterproto.message_field(11) + group_id: int = betterproto.uint32_field(15) + + +@dataclass +class GetStoryLineInfoCsReq(betterproto.Message): + pass + + +@dataclass +class GetStoryLineInfoScRsp(betterproto.Message): + trial_avatar_id_list: List[int] = betterproto.uint32_field(8) + unfinished_story_line_id_list: List[int] = betterproto.uint32_field(1) + retcode: int = betterproto.uint32_field(5) + cur_story_line_id: int = betterproto.uint32_field(9) + + +@dataclass +class StoryLineInfoScNotify(betterproto.Message): + unfinished_story_line_id_list: List[int] = betterproto.uint32_field(3) + cur_story_line_id: int = betterproto.uint32_field(1) + fimcejgdagf: int = betterproto.uint32_field(14) + trial_avatar_id_list: List[int] = betterproto.uint32_field(7) + + +@dataclass +class ChangeStoryLineFinishScNotify(betterproto.Message): + kidkhjecjlf: int = betterproto.uint32_field(9) + cur_story_line_id: int = betterproto.uint32_field(8) + action: "ChangeStoryLineAction" = betterproto.enum_field(15) + koocceighma: bool = betterproto.bool_field(10) + + +@dataclass +class StoryLineTrialAvatarChangeScNotify(betterproto.Message): + kfmffggjmne: List[int] = betterproto.uint32_field(10) + iblbnianphd: List[int] = betterproto.uint32_field(9) + cliigmnmhna: bool = betterproto.bool_field(3) + + +@dataclass +class StrongChallengeAvatar(betterproto.Message): + avatar_id: int = betterproto.uint32_field(14) + avatar_type: "AvatarType" = betterproto.enum_field(3) + + +@dataclass +class JPFJGFOPKHB(betterproto.Message): + buff_list: List[int] = betterproto.uint32_field(11) + avatar_list: List["StrongChallengeAvatar"] = betterproto.message_field(6) + + +@dataclass +class CAAAKPFOEJI(betterproto.Message): + panel_id: int = betterproto.uint32_field(4) + ahinpckgkjg: "JPFJGFOPKHB" = betterproto.message_field(9) + jgbainfdban: int = betterproto.uint32_field(10) + max_score: int = betterproto.uint32_field(6) + stage_id: int = betterproto.uint32_field(2) + + +@dataclass +class HLKGCNFCCIA(betterproto.Message): + alcedmlhflm: Dict[int, "CAAAKPFOEJI"] = betterproto.map_field( + 8, betterproto.TYPE_UINT32, betterproto.TYPE_MESSAGE + ) + + +@dataclass +class GetStrongChallengeActivityDataCsReq(betterproto.Message): + pass + + +@dataclass +class GetStrongChallengeActivityDataScRsp(betterproto.Message): + giilgffkhda: "HLKGCNFCCIA" = betterproto.message_field(8) + retcode: int = betterproto.uint32_field(7) + + +@dataclass +class EnterStrongChallengeActivityStageCsReq(betterproto.Message): + buff_list: List[int] = betterproto.uint32_field(6) + stage_id: int = betterproto.uint32_field(15) + avatar_list: List["StrongChallengeAvatar"] = betterproto.message_field(1) + + +@dataclass +class EnterStrongChallengeActivityStageScRsp(betterproto.Message): + battle_info: "SceneBattleInfo" = betterproto.message_field(7) + stage_id: int = betterproto.uint32_field(15) + retcode: int = betterproto.uint32_field(3) + + +@dataclass +class StrongChallengeActivityBattleEndScNotify(betterproto.Message): + score_id: int = betterproto.uint32_field(6) + total_damage: int = betterproto.uint32_field(10) + ahjfpngdbdo: int = betterproto.uint32_field(4) + stage_id: int = betterproto.uint32_field(11) + max_score: int = betterproto.uint32_field(1) + jamlokncakc: int = betterproto.uint32_field(7) + ggbecchphcd: int = betterproto.uint32_field(2) + end_status: "BattleEndStatus" = betterproto.enum_field(5) + + +@dataclass +class PGBHMOLFBMM(betterproto.Message): + group_id: int = betterproto.uint32_field(7) + star: int = betterproto.uint32_field(8) + nedfibonlkb: int = betterproto.uint32_field(15) + + +@dataclass +class GetSummonActivityDataCsReq(betterproto.Message): + pass + + +@dataclass +class GetSummonActivityDataScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(12) + jhomkemcdmg: List["PGBHMOLFBMM"] = betterproto.message_field(1) + + +@dataclass +class ONOEPLFNELL(betterproto.Message): + avatar_type: "AvatarType" = betterproto.enum_field(1) + avatar_id: int = betterproto.uint32_field(13) + + +@dataclass +class EnterSummonActivityStageCsReq(betterproto.Message): + nedfibonlkb: int = betterproto.uint32_field(9) + group_id: int = betterproto.uint32_field(7) + avatar_list: List["ONOEPLFNELL"] = betterproto.message_field(12) + mnoedeclhbj: "ONOEPLFNELL" = betterproto.message_field(6) + + +@dataclass +class EnterSummonActivityStageScRsp(betterproto.Message): + nedfibonlkb: int = betterproto.uint32_field(2) + battle_info: "SceneBattleInfo" = betterproto.message_field(3) + retcode: int = betterproto.uint32_field(8) + group_id: int = betterproto.uint32_field(9) + + +@dataclass +class SummonActivityBattleEndScNotify(betterproto.Message): + hmffhgbkogl: int = betterproto.uint32_field(11) + nedfibonlkb: int = betterproto.uint32_field(13) + group_id: int = betterproto.uint32_field(5) + star: int = betterproto.uint32_field(7) + + +@dataclass +class HandInfo(betterproto.Message): + config_id: int = betterproto.uint32_field(2) + ofolpkmalgi: "MotionInfo" = betterproto.message_field(14) + mjnnblcdcbj: bytes = betterproto.bytes_field(9) + gfjiiabanlm: int = betterproto.uint32_field(5) + mcbiohmimgn: int = betterproto.uint32_field(4) + + +@dataclass +class SwitchHandDataCsReq(betterproto.Message): + config_id: int = betterproto.uint32_field(13) + + +@dataclass +class SwitchHandDataScRsp(betterproto.Message): + dlnghhdmjjm: int = betterproto.uint32_field(5) + retcode: int = betterproto.uint32_field(2) + abojjandfno: int = betterproto.uint32_field(6) + lbomdfhffcf: List["HandInfo"] = betterproto.message_field(9) + + +@dataclass +class SwitchHandStartCsReq(betterproto.Message): + config_id: int = betterproto.uint32_field(3) + + +@dataclass +class SwitchHandStartScRsp(betterproto.Message): + config_id: int = betterproto.uint32_field(6) + retcode: int = betterproto.uint32_field(8) + + +@dataclass +class SwitchHandFinishCsReq(betterproto.Message): + pass + + +@dataclass +class SwitchHandFinishScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(7) + cmfmacmipee: "HandInfo" = betterproto.message_field(8) + + +@dataclass +class PMGECPBKJCJ(betterproto.Message): + kdlpeighjak: int = betterproto.uint32_field(15) + iefmadjgadb: int = betterproto.uint32_field(7) + group_id: int = betterproto.uint32_field(5) + op_type: "HandPropType" = betterproto.enum_field(3) + + +@dataclass +class SwitchHandUpdateCsReq(betterproto.Message): + opbhjagoagg: "HandInfo" = betterproto.message_field(14) + clbmgbfanlc: "PMGECPBKJCJ" = betterproto.message_field(11) + + +@dataclass +class SwitchHandUpdateScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(10) + cmfmacmipee: "HandInfo" = betterproto.message_field(4) + clbmgbfanlc: "PMGECPBKJCJ" = betterproto.message_field(2) + + +@dataclass +class SwitchHandCoinUpdateCsReq(betterproto.Message): + mcbiohmimgn: int = betterproto.uint32_field(11) + + +@dataclass +class SwitchHandCoinUpdateScRsp(betterproto.Message): + mcbiohmimgn: int = betterproto.uint32_field(9) + retcode: int = betterproto.uint32_field(11) + + +@dataclass +class SwitchHandResetHandPosCsReq(betterproto.Message): + ofolpkmalgi: "MotionInfo" = betterproto.message_field(13) + config_id: int = betterproto.uint32_field(3) + + +@dataclass +class SwitchHandResetHandPosScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(5) + lbomdfhffcf: "HandInfo" = betterproto.message_field(15) + + +@dataclass +class SwitchHandResetGameCsReq(betterproto.Message): + dpjncbbohke: "HandInfo" = betterproto.message_field(5) + + +@dataclass +class SwitchHandResetGameScRsp(betterproto.Message): + lbomdfhffcf: "HandInfo" = betterproto.message_field(10) + retcode: int = betterproto.uint32_field(9) + + +@dataclass +class ALEFDNLLKLB(betterproto.Message): + pending_action: "JKMFMMPMNAM" = betterproto.message_field(11) + nncjoeckcka: "BPPMEIGAHGI" = betterproto.message_field(13) + skill_info: "GJBNIIINKFB" = betterproto.message_field(5) + fdeigepccbp: List[int] = betterproto.uint32_field(4) + eenjbpmndol: int = betterproto.uint32_field(7) + gbeabimobic: "PGGGCFBKDPK" = betterproto.message_field(9) + afpdjdkneni: "OCBOLHFOIGI" = betterproto.message_field(14) + ljgcpnogifo: "DMJLKIFEMMN" = betterproto.message_field(2) + + +@dataclass +class GJBNIIINKFB(betterproto.Message): + cckhkbnmapn: List[int] = betterproto.uint32_field(3) + bilegelkmcb: int = betterproto.uint32_field(6) + mcegaibnmgb: int = betterproto.uint32_field(4) + + +@dataclass +class PGGGCFBKDPK(betterproto.Message): + cnbckefnfge: List[int] = betterproto.uint32_field(1) + game_story_line_id: int = betterproto.uint32_field(14) + + +@dataclass +class MMOIBACBPKA(betterproto.Message): + pjgbfknjpno: "HDIJJMDPILE" = betterproto.enum_field(1) + value: int = betterproto.uint32_field(6) + + +@dataclass +class BPPMEIGAHGI(betterproto.Message): + migfmpjbelg: List["MMOIBACBPKA"] = betterproto.message_field(14) + iomgdikelia: int = betterproto.uint32_field(13) + pdmdkapcojm: int = betterproto.uint32_field(10) + + +@dataclass +class LEEHJGNBGNK(betterproto.Message): + level: int = betterproto.uint32_field(15) + queue_position: int = betterproto.uint32_field(10) + + +@dataclass +class OCBOLHFOIGI(betterproto.Message): + fmdkhadmcoc: List["LEEHJGNBGNK"] = betterproto.message_field(11) + + +@dataclass +class DMJLKIFEMMN(betterproto.Message): + gaibhjhdohb: "KLINPBNKIIA" = betterproto.message_field(10) + kpjafbcpegi: "PBMKKICMLDA" = betterproto.message_field(11) + i_g_h_l_a_b_g_g_i_j_e: int = betterproto.uint32_field(1245) + + +@dataclass +class PIIBOJCEJJN(betterproto.Message): + daily_index: int = betterproto.uint32_field(6) + gimlndloffa: int = betterproto.uint32_field(4) + + +@dataclass +class KLINPBNKIIA(betterproto.Message): + ccljmnckecp: "BJNCDEFEEJI" = betterproto.enum_field(3) + eijdeopofnb: List[int] = betterproto.uint32_field(9) + dncbpcenkif: List["PIIBOJCEJJN"] = betterproto.message_field(14) + + +@dataclass +class PBMKKICMLDA(betterproto.Message): + fhbomfblgpd: int = betterproto.uint32_field(2) + + +@dataclass +class JKMFMMPMNAM(betterproto.Message): + kangpcokfne: "DPDIEGOAGBP" = betterproto.message_field(14) + hhcifnfmkla: "FPEGPJCEOEI" = betterproto.message_field(10) + ocgplmnkmlk: "FKHFONPKDIP" = betterproto.message_field(4) + akmnkladolm: "AEJCCMEPLGO" = betterproto.message_field(9) + kkddandlfbd: "NIGCOPGHAMJ" = betterproto.message_field(15) + affnconkekp: "KHPHAIFNJEI" = betterproto.message_field(12) + cnibngjdnjp: "PLODIDCJOKA" = betterproto.message_field(8) + oapmklfjkkg: "KHCAKPOMGNK" = betterproto.message_field(1) + + +@dataclass +class DPDIEGOAGBP(betterproto.Message): + pass + + +@dataclass +class FPEGPJCEOEI(betterproto.Message): + pass + + +@dataclass +class FKHFONPKDIP(betterproto.Message): + dialogue_id: int = betterproto.uint32_field(5) + + +@dataclass +class AEJCCMEPLGO(betterproto.Message): + pass + + +@dataclass +class NIGCOPGHAMJ(betterproto.Message): + hhgapdfindi: bool = betterproto.bool_field(6) + bglehmkmapg: int = betterproto.uint32_field(11) + + +@dataclass +class KHPHAIFNJEI(betterproto.Message): + pass + + +@dataclass +class PLODIDCJOKA(betterproto.Message): + pass + + +@dataclass +class KHCAKPOMGNK(betterproto.Message): + mmkijaemnbl: bool = betterproto.bool_field(11) + bglehmkmapg: int = betterproto.uint32_field(12) + + +@dataclass +class OMOJDEIFDAM(betterproto.Message): + rogue_action: "CGHKIDBJHFH" = betterproto.message_field(1) + source: "PKHJBPMIBBA" = betterproto.enum_field(15) + + +@dataclass +class CGHKIDBJHFH(betterproto.Message): + pjabkifdnnd: "NLCALKLPGOG" = betterproto.message_field(4) + nihifemokam: "OJLEHPPJBBC" = betterproto.message_field(14) + mlcgalihaip: "OJLEHPPJBBC" = betterproto.message_field(11) + bidddnipble: "OCJGNPIFOBM" = betterproto.message_field(3) + dijhpehonok: "NMENKIGNBCA" = betterproto.message_field(5) + edhbkecgoli: "NIGCOPGHAMJ" = betterproto.message_field(6) + mfhbhkimdca: "HJKDNGIHMAA" = betterproto.message_field(13) + npfpajlclnn: int = betterproto.uint32_field(8) + iomgdikelia: int = betterproto.uint32_field(626) + gkahdhelild: "KHCAKPOMGNK" = betterproto.message_field(1218) + gnpeameljdj: "KHPHAIFNJEI" = betterproto.message_field(1923) + cbakihcdenp: int = betterproto.uint32_field(940) + + +@dataclass +class HJKDNGIHMAA(betterproto.Message): + dialogue_id: int = betterproto.uint32_field(3) + + +@dataclass +class NLCALKLPGOG(betterproto.Message): + pjgbfknjpno: "HDIJJMDPILE" = betterproto.enum_field(8) + bmalpkekbel: int = betterproto.uint32_field(1) + ogjofmcmfpg: int = betterproto.uint32_field(9) + + +@dataclass +class OJLEHPPJBBC(betterproto.Message): + bmalpkekbel: int = betterproto.uint32_field(7) + ogjofmcmfpg: int = betterproto.uint32_field(6) + + +@dataclass +class OCJGNPIFOBM(betterproto.Message): + gffbdandhmk: int = betterproto.uint32_field(15) + level: int = betterproto.uint32_field(12) + queue_position: int = betterproto.uint32_field(6) + + +@dataclass +class NMENKIGNBCA(betterproto.Message): + ifnmbngifph: "DMJLKIFEMMN" = betterproto.message_field(4) + eenjbpmndol: int = betterproto.uint32_field(15) + + +@dataclass +class FGPBIBIJCOH(betterproto.Message): + bglehmkmapg: int = betterproto.uint32_field(15) + hhgapdfindi: bool = betterproto.bool_field(14) + + +@dataclass +class SwordTrainingGameSyncChangeScNotify(betterproto.Message): + leadmneimdp: List["OMOJDEIFDAM"] = betterproto.message_field(3) + + +@dataclass +class HDFKPEEBGEN(betterproto.Message): + progress: int = betterproto.uint32_field(8) + id: int = betterproto.uint32_field(3) + + +@dataclass +class NOKODMNOHMN(betterproto.Message): + nckcmgcbehk: List["HDFKPEEBGEN"] = betterproto.message_field(2) + onilffenamo: List[int] = betterproto.uint32_field(8) + + +@dataclass +class GetSwordTrainingDataCsReq(betterproto.Message): + pass + + +@dataclass +class GetSwordTrainingDataScRsp(betterproto.Message): + klbpecanfig: bool = betterproto.bool_field(11) + kjkbkegighk: "NOKODMNOHMN" = betterproto.message_field(9) + joefnhggago: List[int] = betterproto.uint32_field(3) + dchgiodeddk: int = betterproto.uint32_field(4) + gajbfpcpigm: "ALEFDNLLKLB" = betterproto.message_field(14) + fabkphmjghl: List[int] = betterproto.uint32_field(10) + retcode: int = betterproto.uint32_field(13) + cnbckefnfge: List[int] = betterproto.uint32_field(1) + + +@dataclass +class SwordTrainingTurnActionCsReq(betterproto.Message): + bhnfgpehomo: List[int] = betterproto.uint32_field(3) + phajehibkfi: List[int] = betterproto.uint32_field(8) + + +@dataclass +class SwordTrainingTurnActionScRsp(betterproto.Message): + bhnfgpehomo: List[int] = betterproto.uint32_field(1) + retcode: int = betterproto.uint32_field(6) + + +@dataclass +class SwordTrainingDailyPhaseConfirmCsReq(betterproto.Message): + ifenlnhlbab: "BJNCDEFEEJI" = betterproto.enum_field(5) + + +@dataclass +class SwordTrainingDailyPhaseConfirmScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(5) + mllaefjemcf: bool = betterproto.bool_field(12) + + +@dataclass +class SwordTrainingDialogueSelectOptionCsReq(betterproto.Message): + option_id: int = betterproto.uint32_field(2) + + +@dataclass +class SwordTrainingDialogueSelectOptionScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(5) + + +@dataclass +class SwordTrainingExamResultConfirmCsReq(betterproto.Message): + pass + + +@dataclass +class SwordTrainingExamResultConfirmScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(9) + + +@dataclass +class EnterSwordTrainingExamCsReq(betterproto.Message): + pass + + +@dataclass +class EnterSwordTrainingExamScRsp(betterproto.Message): + battle_info: "SceneBattleInfo" = betterproto.message_field(14) + retcode: int = betterproto.uint32_field(1) + + +@dataclass +class SwordTrainingLearnSkillCsReq(betterproto.Message): + skill_id: int = betterproto.uint32_field(8) + + +@dataclass +class SwordTrainingLearnSkillScRsp(betterproto.Message): + skill_id: int = betterproto.uint32_field(5) + retcode: int = betterproto.uint32_field(12) + + +@dataclass +class SwordTrainingStartGameCsReq(betterproto.Message): + game_story_line_id: int = betterproto.uint32_field(10) + + +@dataclass +class SwordTrainingStartGameScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(5) + gajbfpcpigm: "ALEFDNLLKLB" = betterproto.message_field(3) + + +@dataclass +class SwordTrainingStoryConfirmCsReq(betterproto.Message): + bglehmkmapg: int = betterproto.uint32_field(12) + + +@dataclass +class SwordTrainingStoryConfirmScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(5) + bglehmkmapg: int = betterproto.uint32_field(9) + + +@dataclass +class SwordTrainingGiveUpGameCsReq(betterproto.Message): + pass + + +@dataclass +class SwordTrainingGiveUpGameScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(15) + + +@dataclass +class SwordTrainingGameSettleScNotify(betterproto.Message): + pigeebckcoo: int = betterproto.uint32_field(7) + ppimfpoookb: List[int] = betterproto.uint32_field(15) + reward: "ItemList" = betterproto.message_field(12) + game_story_line_id: int = betterproto.uint32_field(11) + reason: "HDMKPHALALG" = betterproto.enum_field(10) + fpbnipmhanh: int = betterproto.uint32_field(8) + ifnmbngifph: int = betterproto.uint32_field(3) + ccdchkkmgjf: List[int] = betterproto.uint32_field(1) + + +@dataclass +class SwordTrainingUnlockSyncScNotify(betterproto.Message): + nckcmgcbehk: List["HDFKPEEBGEN"] = betterproto.message_field(6) + onilffenamo: List[int] = betterproto.uint32_field(14) + + +@dataclass +class SwordTrainingSelectEndingCsReq(betterproto.Message): + decjmbhnnhd: int = betterproto.uint32_field(12) + + +@dataclass +class SwordTrainingSelectEndingScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(5) + decjmbhnnhd: int = betterproto.uint32_field(10) + + +@dataclass +class SwordTrainingRestoreGameCsReq(betterproto.Message): + pass + + +@dataclass +class SwordTrainingRestoreGameScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(13) + gajbfpcpigm: "ALEFDNLLKLB" = betterproto.message_field(15) + + +@dataclass +class SwordTrainingStoryBattleCsReq(betterproto.Message): + pass + + +@dataclass +class SwordTrainingStoryBattleScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(15) + battle_info: "SceneBattleInfo" = betterproto.message_field(14) + + +@dataclass +class SwordTrainingActionTurnSettleScNotify(betterproto.Message): + cgfcmknccdc: int = betterproto.uint32_field(6) + mcccnliiibc: List["MMOIBACBPKA"] = betterproto.message_field(13) + + +@dataclass +class SwordTrainingResumeGameCsReq(betterproto.Message): + game_story_line_id: int = betterproto.uint32_field(12) + + +@dataclass +class SwordTrainingResumeGameScRsp(betterproto.Message): + gajbfpcpigm: "ALEFDNLLKLB" = betterproto.message_field(15) + retcode: int = betterproto.uint32_field(14) + + +@dataclass +class SwordTrainingSetSkillTraceCsReq(betterproto.Message): + skill_id: int = betterproto.uint32_field(3) + + +@dataclass +class SwordTrainingSetSkillTraceScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(6) + skill_id: int = betterproto.uint32_field(5) + + +@dataclass +class SwordTrainingMarkEndingViewedCsReq(betterproto.Message): + pass + + +@dataclass +class SwordTrainingMarkEndingViewedScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(1) + + +@dataclass +class BasicModuleSync(betterproto.Message): + stamina: int = betterproto.uint32_field(7) + week_cocoon_finished_count: int = betterproto.uint32_field(13) + + +@dataclass +class PlayerBoardModuleSync(betterproto.Message): + signature: str = betterproto.string_field(8) + pagjkdjigpi: bool = betterproto.bool_field(2) + unlocked_head_icon_list: List["HeadIconData"] = betterproto.message_field(10) + almmhkfkhlk: List[int] = betterproto.uint32_field(12) + + +@dataclass +class AvatarSync(betterproto.Message): + avatar_list: List["Avatar"] = betterproto.message_field(1) + + +@dataclass +class MissionSync(betterproto.Message): + hnepoedcidk: List[int] = betterproto.uint32_field(9) + mcfonopkokd: List[int] = betterproto.uint32_field(15) + gaegmbiogoh: List["FHABEIKAFBO"] = betterproto.message_field(11) + mission_list: List["Mission"] = betterproto.message_field(7) + finished_main_mission_id_list: List[int] = betterproto.uint32_field(10) + anihpckngbm: List[int] = betterproto.uint32_field(2) + ejbggjonbol: List["IKAMMKLBOCO"] = betterproto.message_field(6) + + +@dataclass +class DMBMPAHKHLA(betterproto.Message): + dingkfdbcjj: List[int] = betterproto.uint32_field(4) + lkkidnjcfja: List[int] = betterproto.uint32_field(6) + + +@dataclass +class SyncStatus(betterproto.Message): + cngldjnpopi: List[int] = betterproto.uint32_field(14) + lnejlgefple: List[int] = betterproto.uint32_field(7) + message_group_status: List["GroupStatus"] = betterproto.message_field(15) + section_status: List["SectionStatus"] = betterproto.message_field(3) + + +@dataclass +class PlayerSyncScNotify(betterproto.Message): + del_relic_list: List[int] = betterproto.uint32_field(1) + avatar_sync: "AvatarSync" = betterproto.message_field(3) + new_item_hint_list: List[int] = betterproto.uint32_field(526) + multi_path_avatar_info_list: List["MultiPathAvatarInfo"] = ( + betterproto.message_field(161) + ) + material_list: List["Material"] = betterproto.message_field(10) + del_equipment_list: List[int] = betterproto.uint32_field(5) + quest_list: List["Quest"] = betterproto.message_field(6) + basic_module_sync: "BasicModuleSync" = betterproto.message_field(14) + fcokffeapmi: List["Material0"] = betterproto.message_field(1611) + basic_info: "PlayerBasicInfo" = betterproto.message_field(8) + omjopkgjplg: "DMBMPAHKHLA" = betterproto.message_field(1698) + total_achievement_exp: int = betterproto.uint32_field(920) + equipment_list: List["Equipment"] = betterproto.message_field(9) + relic_list: List["Relic"] = betterproto.message_field(11) + sync_status: "SyncStatus" = betterproto.message_field(1333) + igipeimgeaa: List["GKDIHIFFHFD"] = betterproto.message_field(177) + playerboard_module_sync: "PlayerBoardModuleSync" = betterproto.message_field(740) + mjoklhfpgad: "ItemList" = betterproto.message_field(510) + wait_del_resource_list: List["WaitDelResource"] = betterproto.message_field(7) + mission_sync: "MissionSync" = betterproto.message_field(2) + + +@dataclass +class GetNpcTakenRewardCsReq(betterproto.Message): + npc_id: int = betterproto.uint32_field(9) + + +@dataclass +class GetNpcTakenRewardScRsp(betterproto.Message): + npc_id: int = betterproto.uint32_field(4) + talk_event_list: List[int] = betterproto.uint32_field(10) + retcode: int = betterproto.uint32_field(6) + + +@dataclass +class TakeTalkRewardCsReq(betterproto.Message): + olconcnjmmp: "Vector" = betterproto.message_field(9) + iemoeoimhma: int = betterproto.uint32_field(3) + + +@dataclass +class TakeTalkRewardScRsp(betterproto.Message): + reward: "ItemList" = betterproto.message_field(9) + retcode: int = betterproto.uint32_field(14) + iemoeoimhma: int = betterproto.uint32_field(12) + + +@dataclass +class GetFirstTalkNpcCsReq(betterproto.Message): + npc_id_list: List[int] = betterproto.uint32_field(9) + + +@dataclass +class FirstNpcTalkInfo(betterproto.Message): + npc_id: int = betterproto.uint32_field(5) + is_meet: bool = betterproto.bool_field(4) + + +@dataclass +class GetFirstTalkNpcScRsp(betterproto.Message): + npc_meet_status_list: List["FirstNpcTalkInfo"] = betterproto.message_field(9) + retcode: int = betterproto.uint32_field(8) + + +@dataclass +class FinishFirstTalkNpcCsReq(betterproto.Message): + npc_id: int = betterproto.uint32_field(10) + + +@dataclass +class FinishFirstTalkNpcScRsp(betterproto.Message): + npc_id: int = betterproto.uint32_field(3) + retcode: int = betterproto.uint32_field(7) + + +@dataclass +class SelectInclinationTextCsReq(betterproto.Message): + talk_sentence_id: int = betterproto.uint32_field(10) + + +@dataclass +class SelectInclinationTextScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(11) + talk_sentence_id: int = betterproto.uint32_field(10) + + +@dataclass +class NpcMeetByPerformanceStatus(betterproto.Message): + performance_id: int = betterproto.uint32_field(15) + is_meet: bool = betterproto.bool_field(4) + + +@dataclass +class GetFirstTalkByPerformanceNpcCsReq(betterproto.Message): + performance_id_list: List[int] = betterproto.uint32_field(6) + + +@dataclass +class GetFirstTalkByPerformanceNpcScRsp(betterproto.Message): + npc_meet_status_list: List["NpcMeetByPerformanceStatus"] = ( + betterproto.message_field(14) + ) + retcode: int = betterproto.uint32_field(4) + + +@dataclass +class FinishFirstTalkByPerformanceNpcCsReq(betterproto.Message): + performance_id: int = betterproto.uint32_field(8) + + +@dataclass +class FinishFirstTalkByPerformanceNpcScRsp(betterproto.Message): + reward: "ItemList" = betterproto.message_field(6) + retcode: int = betterproto.uint32_field(1) + performance_id: int = betterproto.uint32_field(11) + + +@dataclass +class EJDGKNKHKHH(betterproto.Message): + id: int = betterproto.uint32_field(14) + level: int = betterproto.uint32_field(7) + + +@dataclass +class BKMGDPHACKE(betterproto.Message): + id: int = betterproto.uint32_field(3) + biinncndpcg: bool = betterproto.bool_field(15) + + +@dataclass +class FLOICKMNMLL(betterproto.Message): + dgpejfljnoj: List["BKMGDPHACKE"] = betterproto.message_field(4) + cnijnmdgedd: List["EJDGKNKHKHH"] = betterproto.message_field(11) + + +@dataclass +class OFDGOGDBHAC(betterproto.Message): + libllkbldch: List[int] = betterproto.uint32_field(6) + + +@dataclass +class TarotBookGetDataCsReq(betterproto.Message): + pass + + +@dataclass +class TarotBookGetDataScRsp(betterproto.Message): + jkemdjiamhi: Dict[int, int] = betterproto.map_field( + 1, betterproto.TYPE_UINT32, betterproto.TYPE_UINT32 + ) + retcode: int = betterproto.uint32_field(3) + hefjejhojea: "FLOICKMNMLL" = betterproto.message_field(12) + ndcjjpgnfln: Dict[int, int] = betterproto.map_field( + 5, betterproto.TYPE_UINT32, betterproto.TYPE_UINT32 + ) + ipninopekbp: "OFDGOGDBHAC" = betterproto.message_field(15) + fdckfkfkhlo: int = betterproto.uint32_field(4) + energy_info: int = betterproto.uint32_field(13) + + +@dataclass +class TarotBookOpenPackCsReq(betterproto.Message): + pass + + +@dataclass +class TarotBookOpenPackScRsp(betterproto.Message): + fdckfkfkhlo: int = betterproto.uint32_field(15) + cjencdiflcf: Dict[int, int] = betterproto.map_field( + 11, betterproto.TYPE_UINT32, betterproto.TYPE_UINT32 + ) + iikbcnbjkki: Dict[int, int] = betterproto.map_field( + 13, betterproto.TYPE_UINT32, betterproto.TYPE_UINT32 + ) + retcode: int = betterproto.uint32_field(12) + energy_info: int = betterproto.uint32_field(4) + + +@dataclass +class TarotBookUnlockStoryCsReq(betterproto.Message): + ppimfpoookb: List[int] = betterproto.uint32_field(4) + + +@dataclass +class TarotBookUnlockStoryScRsp(betterproto.Message): + ndcjjpgnfln: Dict[int, int] = betterproto.map_field( + 15, betterproto.TYPE_UINT32, betterproto.TYPE_UINT32 + ) + jkemdjiamhi: Dict[int, int] = betterproto.map_field( + 10, betterproto.TYPE_UINT32, betterproto.TYPE_UINT32 + ) + retcode: int = betterproto.uint32_field(3) + ppdggociede: "EJDGKNKHKHH" = betterproto.message_field(14) + ppimfpoookb: List[int] = betterproto.uint32_field(1) + + +@dataclass +class TarotBookFinishStoryCsReq(betterproto.Message): + bglehmkmapg: int = betterproto.uint32_field(7) + + +@dataclass +class TarotBookFinishStoryScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(15) + hefjejhojea: "FLOICKMNMLL" = betterproto.message_field(13) + bglehmkmapg: int = betterproto.uint32_field(14) + + +@dataclass +class TarotBookModifyEnergyScNotify(betterproto.Message): + sub_mission_id: int = betterproto.uint32_field(10) + energy_info: int = betterproto.uint32_field(11) + + +@dataclass +class TarotBookFinishInteractionCsReq(betterproto.Message): + nblhjjjegno: int = betterproto.uint32_field(5) + + +@dataclass +class TarotBookFinishInteractionScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(6) + nblhjjjegno: int = betterproto.uint32_field(10) + + +@dataclass +class OGJDNLIJKFB(betterproto.Message): + kegcjppokbk: int = betterproto.uint32_field(13) + ninlfbglbll: int = betterproto.uint32_field(6) + max_score: int = betterproto.uint32_field(8) + + +@dataclass +class GetTelevisionActivityDataCsReq(betterproto.Message): + pass + + +@dataclass +class GetTelevisionActivityDataScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(11) + kadgmhhgkmp: List["OGJDNLIJKFB"] = betterproto.message_field(15) + + +@dataclass +class TelevisionActivityDataChangeScNotify(betterproto.Message): + kadgmhhgkmp: List["OGJDNLIJKFB"] = betterproto.message_field(11) + + +@dataclass +class TelevisionActivityBattleEndScNotify(betterproto.Message): + fcepipccomn: int = betterproto.uint32_field(1) + hoehiobiiej: int = betterproto.uint32_field(14) + dfccbdpnlea: "OGJDNLIJKFB" = betterproto.message_field(6) + fidioihllga: int = betterproto.uint32_field(12) + npjeecedpok: int = betterproto.uint32_field(11) + + +@dataclass +class DEPEAHJNKGJ(betterproto.Message): + avatar_id: int = betterproto.uint32_field(3) + avatar_type: "AvatarType" = betterproto.enum_field(10) + + +@dataclass +class EnterTelevisionActivityStageCsReq(betterproto.Message): + ninlfbglbll: int = betterproto.uint32_field(1) + avatar_list: List["DEPEAHJNKGJ"] = betterproto.message_field(8) + buff_list: List[int] = betterproto.uint32_field(3) + + +@dataclass +class EnterTelevisionActivityStageScRsp(betterproto.Message): + battle_info: "SceneBattleInfo" = betterproto.message_field(4) + retcode: int = betterproto.uint32_field(3) + ninlfbglbll: int = betterproto.uint32_field(11) + + +@dataclass +class IOMOPENEMBF(betterproto.Message): + nlfnjpmacpm: int = betterproto.uint32_field(14) + adinnbpinak: int = betterproto.uint32_field(10) + nkioiioiaog: str = betterproto.string_field(13) + hbjkeebdjml: str = betterproto.string_field(6) + fanokembmpb: int = betterproto.uint32_field(2) + + +@dataclass +class TextJoinSaveCsReq(betterproto.Message): + hbjkeebdjml: str = betterproto.string_field(7) + adinnbpinak: int = betterproto.uint32_field(6) + fanokembmpb: int = betterproto.uint32_field(5) + + +@dataclass +class TextJoinSaveScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(2) + hbjkeebdjml: str = betterproto.string_field(13) + adinnbpinak: int = betterproto.uint32_field(3) + fanokembmpb: int = betterproto.uint32_field(12) + + +@dataclass +class TextJoinQueryCsReq(betterproto.Message): + ponennkhcmj: List[int] = betterproto.uint32_field(13) + + +@dataclass +class TextJoinQueryScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(1) + nkkkopacokg: List["IOMOPENEMBF"] = betterproto.message_field(3) + + +@dataclass +class TextJoinBatchSaveCsReq(betterproto.Message): + nkkkopacokg: List["IOMOPENEMBF"] = betterproto.message_field(1) + + +@dataclass +class TextJoinBatchSaveScRsp(betterproto.Message): + nkkkopacokg: List["IOMOPENEMBF"] = betterproto.message_field(12) + retcode: int = betterproto.uint32_field(5) + + +@dataclass +class CGLIGECGAKN(betterproto.Message): + stage_id: int = betterproto.uint32_field(4) + max_score: int = betterproto.uint32_field(5) + + +@dataclass +class GetTrackPhotoActivityDataCsReq(betterproto.Message): + pass + + +@dataclass +class GetTrackPhotoActivityDataScRsp(betterproto.Message): + emgfldopkgl: List["CGLIGECGAKN"] = betterproto.message_field(1) + retcode: int = betterproto.uint32_field(14) + + +@dataclass +class GEOAEOFJOGC(betterproto.Message): + kfboaonldem: bool = betterproto.bool_field(5) + entity_id: int = betterproto.uint32_field(12) + + +@dataclass +class SettleTrackPhotoStageCsReq(betterproto.Message): + cost_time: int = betterproto.uint32_field(4) + stage_id: int = betterproto.uint32_field(12) + lpihaniojfi: List["GEOAEOFJOGC"] = betterproto.message_field(2) + + +@dataclass +class SettleTrackPhotoStageScRsp(betterproto.Message): + score_id: int = betterproto.uint32_field(6) + lpihaniojfi: List["GEOAEOFJOGC"] = betterproto.message_field(12) + retcode: int = betterproto.uint32_field(15) + stage_id: int = betterproto.uint32_field(10) + + +@dataclass +class StartTrackPhotoStageCsReq(betterproto.Message): + djfcmlipdab: bool = betterproto.bool_field(2) + stage_id: int = betterproto.uint32_field(8) + + +@dataclass +class StartTrackPhotoStageScRsp(betterproto.Message): + mdlndgijnml: int = betterproto.uint32_field(4) + retcode: int = betterproto.uint32_field(14) + + +@dataclass +class QuitTrackPhotoStageCsReq(betterproto.Message): + stage_id: int = betterproto.uint32_field(5) + + +@dataclass +class QuitTrackPhotoStageScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(7) + + +@dataclass +class FPLMDELMJKB(betterproto.Message): + cur_index: int = betterproto.uint32_field(1) + card_id: int = betterproto.uint32_field(4) + unique_id: int = betterproto.uint32_field(15) + hcpgealodme: List[int] = betterproto.uint32_field(6) + + +@dataclass +class HBCINIKPAFI(betterproto.Message): + fodpdmpband: List["FPLMDELMJKB"] = betterproto.message_field(11) + + +@dataclass +class CGCONJFFFBB(betterproto.Message): + fodpdmpband: "HBCINIKPAFI" = betterproto.message_field(14) + hafckonehfm: int = betterproto.uint32_field(2) + lkllmpokogh: bool = betterproto.bool_field(6) + + +@dataclass +class KKNLMCJIGAF(betterproto.Message): + unique_id: int = betterproto.uint32_field(13) + hfnhlcfnhkd: int = betterproto.uint32_field(11) + ghfaihlceln: int = betterproto.uint32_field(7) + display_value: int = betterproto.uint32_field(4) + + +@dataclass +class KACKJJDJONI(betterproto.Message): + ncdcgfkoloe: int = betterproto.uint32_field(2) + papkgjojpii: int = betterproto.uint32_field(10) + hcfocpkfobg: int = betterproto.uint32_field(7) + jodnmdoamkc: int = betterproto.uint32_field(1) + blhpiciofai: int = betterproto.uint32_field(13) + kddppgocomb: List[int] = betterproto.uint32_field(5) + + +@dataclass +class EDFABKMNBLI(betterproto.Message): + bihmelmjhpo: int = betterproto.uint32_field(8) + mkoambmkdid: List["KKNLMCJIGAF"] = betterproto.message_field(7) + gdghcbghlnd: "KACKJJDJONI" = betterproto.message_field(11) + lljefmpdjkh: int = betterproto.uint32_field(9) + + +@dataclass +class FPDFCGKIILE(betterproto.Message): + khhlnggecpb: int = betterproto.uint32_field(14) + kpakapnhnnd: int = betterproto.uint32_field(6) + + +@dataclass +class GOCKBLNJIBG(betterproto.Message): + jgmipmdppij: int = betterproto.uint32_field(13) + skill_id: int = betterproto.uint32_field(9) + skill_level: int = betterproto.uint32_field(4) + + +@dataclass +class MAONNNELGCC(betterproto.Message): + bojbpoelfci: "FPDFCGKIILE" = betterproto.message_field(9) + passenger_id: int = betterproto.uint32_field(13) + mihlfgcgkno: int = betterproto.uint32_field(12) + + +@dataclass +class TrainPartyPassenger(betterproto.Message): + pclmnbilaph: List[int] = betterproto.uint32_field(11) + cinmlckbhim: bool = betterproto.bool_field(8) + passenger_id: int = betterproto.uint32_field(4) + record_id: int = betterproto.uint32_field(6) + + +@dataclass +class LHLEEHCBMOL(betterproto.Message): + cfkpaicdjpj: List[int] = betterproto.uint32_field(11) + skill_list: List["GOCKBLNJIBG"] = betterproto.message_field(1) + kbgdcehiffj: List["MAONNNELGCC"] = betterproto.message_field(15) + cur_index: int = betterproto.uint32_field(12) + pkidbdgpilo: int = betterproto.uint32_field(14) + oafaaeemnfb: int = betterproto.uint32_field(10) + + +@dataclass +class TrainPartyPassengerInfo(betterproto.Message): + pclmnbilaph: List[int] = betterproto.uint32_field(6) + passenger_info_list: List["TrainPartyPassenger"] = betterproto.message_field(14) + + +@dataclass +class TrainPartyArea(betterproto.Message): + progress: int = betterproto.uint32_field(12) + step_id_list: List[int] = betterproto.uint32_field(15) + dynamic_info: List["AreaDynamicInfo"] = betterproto.message_field(8) + area_step_info: "AreaStepInfo" = betterproto.message_field(9) + area_id: int = betterproto.uint32_field(14) + verify_step_id_list: List[int] = betterproto.uint32_field(11) + static_prop_id_list: List[int] = betterproto.uint32_field(3) + + +@dataclass +class INDFFNNHOHC(betterproto.Message): + area_id: int = betterproto.uint32_field(13) + step_id_list: List[int] = betterproto.uint32_field(11) + + +@dataclass +class PPKDPAJPAGF(betterproto.Message): + jlhdkolmeda: int = betterproto.uint32_field(10) + gjfhpcieboj: int = betterproto.uint32_field(1) + status: "KNOOCOCANAM" = betterproto.enum_field(7) + + +@dataclass +class AreaStepInfo(betterproto.Message): + imekhgciedn: List["PPKDPAJPAGF"] = betterproto.message_field(13) + heidcikedpd: int = betterproto.uint32_field(3) + + +@dataclass +class AreaDynamicInfo(betterproto.Message): + diy_dynamic_id: int = betterproto.uint32_field(14) + dice_slot_id: int = betterproto.uint32_field(13) + + +@dataclass +class TrainPartyInfo(betterproto.Message): + eebnaapbkcn: int = betterproto.uint32_field(8) + ppffkfgollj: int = betterproto.uint32_field(7) + dynamic_id_list: List[int] = betterproto.uint32_field(12) + flbnekgidbo: int = betterproto.uint32_field(5) + area_list: List["TrainPartyArea"] = betterproto.message_field(3) + eohbbeakodf: List["INDFFNNHOHC"] = betterproto.message_field(10) + cnajoignmlj: int = betterproto.uint32_field(4) + cur_fund: int = betterproto.uint32_field(6) + cigacghpdgk: List[int] = betterproto.uint32_field(9) + obokglcmkke: int = betterproto.uint32_field(1) + + +@dataclass +class TrainPartyData(betterproto.Message): + cefmbafcnpk: "CDNGNDNLNAJ" = betterproto.message_field(6) + record_id: int = betterproto.uint32_field(5) + train_party_info: "TrainPartyInfo" = betterproto.message_field(11) + unlock_area_num: int = betterproto.uint32_field(9) + aianofknlhg: int = betterproto.uint32_field(15) + passenger_info: "TrainPartyPassengerInfo" = betterproto.message_field(3) + + +@dataclass +class CDNGNDNLNAJ(betterproto.Message): + gbfclmlimhc: "GCFEHMENONM" = betterproto.message_field(7) + eeihdcpolef: "EDFABKMNBLI" = betterproto.message_field(2) + aakhcnedbcd: "LHLEEHCBMOL" = betterproto.message_field(6) + hbheajijegf: "CGCONJFFFBB" = betterproto.message_field(9) + goneakbdgek: int = betterproto.uint32_field(4) + + +@dataclass +class TrainPartyGetDataCsReq(betterproto.Message): + pass + + +@dataclass +class TrainPartyGetDataScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(7) + train_party_data: "TrainPartyData" = betterproto.message_field(10) + + +@dataclass +class TrainPartyUseCardCsReq(betterproto.Message): + eeghhhkcghb: int = betterproto.uint32_field(12) + + +@dataclass +class TrainPartyUseCardScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(11) + eeghhhkcghb: int = betterproto.uint32_field(14) + + +@dataclass +class TrainPartyMoveScNotify(betterproto.Message): + gheeoeohmfi: int = betterproto.uint32_field(11) + peadiocnimf: List["KKNLMCJIGAF"] = betterproto.message_field(14) + + +@dataclass +class TrainPartySettleNotify(betterproto.Message): + hilomekafbp: "FKMBFLMEGEB" = betterproto.message_field(10) + eeghhhkcghb: int = betterproto.uint32_field(5) + + +@dataclass +class FKMBFLMEGEB(betterproto.Message): + foaplialhdi: List["BAEPNHDCIEM"] = betterproto.message_field(10) + heijcnlnhhi: int = betterproto.uint32_field(7) + kbgdcehiffj: List["MAONNNELGCC"] = betterproto.message_field(14) + + +@dataclass +class BAEPNHDCIEM(betterproto.Message): + ijfihgcknhg: int = betterproto.uint32_field(1) + switch_list: List[int] = betterproto.uint32_field(9) + + +@dataclass +class NCLCBOPCEJG(betterproto.Message): + hmffhbhalge: "FPLMDELMJKB" = betterproto.message_field(3) + + +@dataclass +class IDBEOMMCKIK(betterproto.Message): + passenger_id: int = betterproto.uint32_field(15) + bojbpoelfci: "FPDFCGKIILE" = betterproto.message_field(1) + + +@dataclass +class IBOMHKHBAAO(betterproto.Message): + nfeolnaogdk: List["IDBEOMMCKIK"] = betterproto.message_field(9) + + +@dataclass +class ENJHDLHKINO(betterproto.Message): + pending_action: "GCFEHMENONM" = betterproto.message_field(3) + + +@dataclass +class FNOGHGHPJPD(betterproto.Message): + cur_index: int = betterproto.uint32_field(4) + + +@dataclass +class JLDHCFGGEAO(betterproto.Message): + mhmeddehbhi: "GOCKBLNJIBG" = betterproto.message_field(12) + + +@dataclass +class PFGIAHAIDLM(betterproto.Message): + skill_list: List["GOCKBLNJIBG"] = betterproto.message_field(12) + + +@dataclass +class JHMNLCOBJCJ(betterproto.Message): + abbnhmggpil: "TrainPartyPassenger" = betterproto.message_field(12) + + +@dataclass +class FKJLBFNIGGM(betterproto.Message): + pclmnbilaph: List[int] = betterproto.uint32_field(13) + + +@dataclass +class HAKMEBIAJCF(betterproto.Message): + mkoambmkdid: List["KKNLMCJIGAF"] = betterproto.message_field(10) + + +@dataclass +class HMOPIBLFCLN(betterproto.Message): + gdghcbghlnd: "KACKJJDJONI" = betterproto.message_field(12) + lnmmkfmeajm: "HBCINIKPAFI" = betterproto.message_field(14) + hafckonehfm: int = betterproto.uint32_field(3) + lkllmpokogh: bool = betterproto.bool_field(8) + + +@dataclass +class PLKCMGDEDCK(betterproto.Message): + lnmmkfmeajm: "HBCINIKPAFI" = betterproto.message_field(1121) + fpfdjndnpim: "IBOMHKHBAAO" = betterproto.message_field(1638) + njkjnbdboca: "ENJHDLHKINO" = betterproto.message_field(900) + lgjgbighonp: "FNOGHGHPJPD" = betterproto.message_field(542) + dgnkbngipki: "HAKMEBIAJCF" = betterproto.message_field(379) + mkkpchhnhcj: "JLDHCFGGEAO" = betterproto.message_field(250) + pkpjefggboo: "HMOPIBLFCLN" = betterproto.message_field(1085) + nhacnnjpalp: "PFGIAHAIDLM" = betterproto.message_field(1394) + ahpdpooljle: "JHMNLCOBJCJ" = betterproto.message_field(865) + afmieicdnea: "FKJLBFNIGGM" = betterproto.message_field(1321) + src: "CBEJAJENOHJ" = betterproto.enum_field(9) + + +@dataclass +class TrainPartySyncUpdateScNotify(betterproto.Message): + fflpklldhlm: List["PLKCMGDEDCK"] = betterproto.message_field(4) + + +@dataclass +class GCFEHMENONM(betterproto.Message): + iamkdjcfmib: "NJKENNCJLCF" = betterproto.message_field(1184) + leehaeobeba: "MIIAIODLEOA" = betterproto.message_field(343) + oaoofnjgidh: "EMMDENJBFPF" = betterproto.message_field(238) + pmmgocjfeej: "EPBGFBEDANM" = betterproto.message_field(700) + queue_position: int = betterproto.uint32_field(14) + + +@dataclass +class HHPIAFBHJCF(betterproto.Message): + option_id: int = betterproto.uint32_field(8) + confirm: bool = betterproto.bool_field(12) + + +@dataclass +class NJKENNCJLCF(betterproto.Message): + event_id: int = betterproto.uint32_field(7) + hoiokbkgfdn: "IJDNOJEMIAN" = betterproto.enum_field(10) + option_list: List["HHPIAFBHJCF"] = betterproto.message_field(9) + + +@dataclass +class HPFKGDDIFHG(betterproto.Message): + option_id: int = betterproto.uint32_field(4) + event_id: int = betterproto.uint32_field(3) + + +@dataclass +class BFIFANAOCPC(betterproto.Message): + hilomekafbp: "FKMBFLMEGEB" = betterproto.message_field(5) + + +@dataclass +class OCMHOFEMNHI(betterproto.Message): + level: int = betterproto.uint32_field(7) + skill_id: int = betterproto.uint32_field(14) + jgmipmdppij: int = betterproto.uint32_field(4) + + +@dataclass +class MIIAIODLEOA(betterproto.Message): + ganakfaibfc: List["OCMHOFEMNHI"] = betterproto.message_field(10) + passenger_id: int = betterproto.uint32_field(11) + + +@dataclass +class EPBGFBEDANM(betterproto.Message): + llijagdkjco: List["GOCKBLNJIBG"] = betterproto.message_field(8) + idaihkmmdek: int = betterproto.uint32_field(11) + + +@dataclass +class GLBFBNHFCNO(betterproto.Message): + iehhdalhgpi: int = betterproto.uint32_field(15) + + +@dataclass +class MBINMAONBCD(betterproto.Message): + skill_list: List["GOCKBLNJIBG"] = betterproto.message_field(14) + + +@dataclass +class PJJDMMBKKCN(betterproto.Message): + khhlnggecpb: int = betterproto.uint32_field(14) + passenger_id: int = betterproto.uint32_field(11) + unique_id: int = betterproto.uint32_field(2) + + +@dataclass +class HEOJLDBKKGE(betterproto.Message): + passenger_id: int = betterproto.uint32_field(14) + num: int = betterproto.uint32_field(15) + + +@dataclass +class EMMDENJBFPF(betterproto.Message): + cfokigihcfp: int = betterproto.uint32_field(9) + kmlppmnmpke: int = betterproto.uint32_field(2) + mmeiphbnked: List["PJJDMMBKKCN"] = betterproto.message_field(7) + mlipplkiifd: int = betterproto.uint32_field(14) + mliijgoaeck: int = betterproto.uint32_field(8) + ccgbhhfbafj: List["HEOJLDBKKGE"] = betterproto.message_field(4) + kjmliamgdle: List["BJGLDLJKIDH"] = betterproto.message_field(3) + npjeecedpok: int = betterproto.uint32_field(12) + + +@dataclass +class PlaySkillBrief(betterproto.Message): + skill_id: int = betterproto.uint32_field(11) + skill_param: int = betterproto.uint32_field(12) + skill_type: "LCDEMGACEKD" = betterproto.enum_field(10) + + +@dataclass +class PlayCardBrief(betterproto.Message): + base_value: int = betterproto.uint32_field(8) + skill_brief_list: List["PlaySkillBrief"] = betterproto.message_field(15) + unique_id: int = betterproto.uint32_field(5) + + +@dataclass +class PHOEFKFBIKD(betterproto.Message): + npojmhhibki: List[int] = betterproto.uint32_field(1) + mkegodinhnc: int = betterproto.uint32_field(12) + ojcjnbgnicf: "ItemList" = betterproto.message_field(4) + + +@dataclass +class PECGLKCICGO(betterproto.Message): + canngfdafoe: List[int] = betterproto.uint32_field(13) + + +@dataclass +class JBOCJHNDAMC(betterproto.Message): + mmeiphbnked: List["PJJDMMBKKCN"] = betterproto.message_field(14) + gdghcbghlnd: "KACKJJDJONI" = betterproto.message_field(12) + mfakjhfmaib: "PHOEFKFBIKD" = betterproto.message_field(10) + score_id: int = betterproto.uint32_field(5) + omggnaeahif: List["PlayCardBrief"] = betterproto.message_field(7) + ijppknknlnl: "DMLCPAKDBLJ" = betterproto.enum_field(3) + ccgbhhfbafj: List["HEOJLDBKKGE"] = betterproto.message_field(9) + bihfecjhpgh: List["PlaySkillBrief"] = betterproto.message_field(1) + npjeecedpok: int = betterproto.uint32_field(8) + cfokigihcfp: int = betterproto.uint32_field(11) + + +@dataclass +class ENCJKPGOIAL(betterproto.Message): + canngfdafoe: List[int] = betterproto.uint32_field(13) + + +@dataclass +class FBGLLDNLGPE(betterproto.Message): + mmeiphbnked: List["PJJDMMBKKCN"] = betterproto.message_field(12) + nicgnemched: List["PlaySkillBrief"] = betterproto.message_field(8) + kmlppmnmpke: int = betterproto.uint32_field(9) + ccgbhhfbafj: List["HEOJLDBKKGE"] = betterproto.message_field(4) + + +@dataclass +class TrainPartyHandlePendingActionCsReq(betterproto.Message): + iamkdjcfmib: "HPFKGDDIFHG" = betterproto.message_field(147) + pmmgocjfeej: "GLBFBNHFCNO" = betterproto.message_field(1939) + lgbjaeldpnb: "PECGLKCICGO" = betterproto.message_field(1515) + bgjmfbhcmkl: "ENCJKPGOIAL" = betterproto.message_field(1133) + queue_position: int = betterproto.uint32_field(14) + + +@dataclass +class TrainPartyHandlePendingActionScRsp(betterproto.Message): + laelpnhhjik: "BFIFANAOCPC" = betterproto.message_field(1786) + pmojbjmkfan: "MBINMAONBCD" = betterproto.message_field(1293) + afdndbaddkp: "JBOCJHNDAMC" = betterproto.message_field(1590) + ledfncdfamk: "FBGLLDNLGPE" = betterproto.message_field(1088) + h_i_l_o_m_e_k_a_f_b_p: "FKMBFLMEGEB" = betterproto.message_field(2) + retcode: int = betterproto.uint32_field(1) + queue_position: int = betterproto.uint32_field(11) + d_l_n_c_b_j_f_g_k_a_a: bool = betterproto.bool_field(9) + + +@dataclass +class TrainPartyBuildStartStepCsReq(betterproto.Message): + area_id: int = betterproto.uint32_field(6) + heidcikedpd: int = betterproto.uint32_field(13) + alaoddbghpl: "AreaDynamicInfo" = betterproto.message_field(9) + gjfhpcieboj: int = betterproto.uint32_field(2) + + +@dataclass +class TrainPartyBuildStartStepScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(5) + cur_fund: int = betterproto.uint32_field(15) + + +@dataclass +class CIKOHJNAGON(betterproto.Message): + kcjbmkjlfba: "AreaDynamicInfo" = betterproto.message_field(1) + area_id: int = betterproto.uint32_field(13) + + +@dataclass +class TrainPartyBuildDiyCsReq(betterproto.Message): + diy_dynamic_id: int = betterproto.uint32_field(13) + dice_slot_id: int = betterproto.uint32_field(3) + area_id: int = betterproto.uint32_field(8) + ganhklnpapi: bool = betterproto.bool_field(10) + + +@dataclass +class TrainPartyBuildDiyScRsp(betterproto.Message): + fflpklldhlm: List["CIKOHJNAGON"] = betterproto.message_field(9) + retcode: int = betterproto.uint32_field(4) + ganhklnpapi: bool = betterproto.bool_field(5) + dynamic_info: List["AreaDynamicInfo"] = betterproto.message_field(10) + area_id: int = betterproto.uint32_field(11) + + +@dataclass +class KMBDKDLNHMC(betterproto.Message): + cgfihjccgcd: List["PPKDPAJPAGF"] = betterproto.message_field(11) + okhcjkljghf: int = betterproto.uint32_field(1) + + +@dataclass +class JNAHOJLCNJA(betterproto.Message): + heidcikedpd: int = betterproto.uint32_field(13) + progress: int = betterproto.uint32_field(7) + area_id: int = betterproto.uint32_field(9) + cgfihjccgcd: List["PPKDPAJPAGF"] = betterproto.message_field(5) + + +@dataclass +class IEFKFKFMEPL(betterproto.Message): + obokglcmkke: int = betterproto.uint32_field(11) + ppffkfgollj: int = betterproto.uint32_field(8) + + +@dataclass +class FNPMCDNKDFJ(betterproto.Message): + bdccopiehin: int = betterproto.uint32_field(11) + + +@dataclass +class GEGJHBMLOEM(betterproto.Message): + flbnekgidbo: int = betterproto.uint32_field(10) + + +@dataclass +class BFDDPPLMKPG(betterproto.Message): + mnleikiehhp: int = betterproto.uint32_field(6) + area_id: int = betterproto.uint32_field(15) + + +@dataclass +class KMLEHLLOGJG(betterproto.Message): + diy_dynamic_id: int = betterproto.uint32_field(13) + + +@dataclass +class OKFGJEIHLJM(betterproto.Message): + fbfihjiiabo: int = betterproto.uint32_field(5) + + +@dataclass +class KAKJCJOMFGH(betterproto.Message): + cnajoignmlj: int = betterproto.uint32_field(15) + + +@dataclass +class MCLNCBCPAFF(betterproto.Message): + area_id: int = betterproto.uint32_field(2) + cgfihjccgcd: List[int] = betterproto.uint32_field(13) + + +@dataclass +class LNDGCGOBDJL(betterproto.Message): + area_list: List["MCLNCBCPAFF"] = betterproto.message_field(9) + + +@dataclass +class PPKGJKIFELK(betterproto.Message): + maplogdnbgb: "OKFGJEIHLJM" = betterproto.message_field(917) + ekflejankme: "KMBDKDLNHMC" = betterproto.message_field(1834) + jobejafkecd: "JNAHOJLCNJA" = betterproto.message_field(645) + dblbhnphhkb: "IEFKFKFMEPL" = betterproto.message_field(497) + ckbnojapnnb: "FNPMCDNKDFJ" = betterproto.message_field(265) + nepconhofkj: "BFDDPPLMKPG" = betterproto.message_field(204) + egdgpikbnlk: "KMLEHLLOGJG" = betterproto.message_field(1686) + bhofhhemlog: "GEGJHBMLOEM" = betterproto.message_field(803) + haeadfoolnd: "KAKJCJOMFGH" = betterproto.message_field(1940) + gaibcbghhgl: "LNDGCGOBDJL" = betterproto.message_field(152) + + +@dataclass +class TrainPartyBuildingUpdateNotify(betterproto.Message): + bjdfkemkaol: List["PPKGJKIFELK"] = betterproto.message_field(15) + + +@dataclass +class TrainPartyEnterCsReq(betterproto.Message): + pass + + +@dataclass +class TrainPartyEnterScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(4) + + +@dataclass +class TrainPartyLeaveCsReq(betterproto.Message): + pass + + +@dataclass +class TrainPartyLeaveScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(8) + + +@dataclass +class BJGLDLJKIDH(betterproto.Message): + jllnmgbenaf: "DMLCPAKDBLJ" = betterproto.enum_field(3) + level: int = betterproto.uint32_field(14) + + +@dataclass +class TrainPartyGamePlaySettleNotify(betterproto.Message): + olbagkmfdaj: List[int] = betterproto.uint32_field(8) + hanfphgemgf: "TrainPartyPassengerInfo" = betterproto.message_field(6) + record_id: int = betterproto.uint32_field(13) + aianofknlhg: int = betterproto.uint32_field(3) + + +@dataclass +class TrainPartyGamePlayStartCsReq(betterproto.Message): + goneakbdgek: int = betterproto.uint32_field(4) + kbgdcehiffj: List[int] = betterproto.uint32_field(13) + + +@dataclass +class TrainPartyGamePlayStartScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(13) + kmdphcmbjgb: "CDNGNDNLNAJ" = betterproto.message_field(8) + + +@dataclass +class TrainPartyAddBuildDynamicBuffCsReq(betterproto.Message): + pass + + +@dataclass +class TrainPartyAddBuildDynamicBuffScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(11) + buff_id: int = betterproto.uint32_field(12) + + +@dataclass +class TrainPartyTakeBuildLevelAwardCsReq(betterproto.Message): + ecclpifmmpp: int = betterproto.uint32_field(14) + + +@dataclass +class TrainPartyTakeBuildLevelAwardScRsp(betterproto.Message): + ecclpifmmpp: int = betterproto.uint32_field(7) + retcode: int = betterproto.uint32_field(10) + item_list: "ItemList" = betterproto.message_field(4) + + +@dataclass +class TrainVisitorBehavior(betterproto.Message): + visitor_id: int = betterproto.uint32_field(2) + is_meet: bool = betterproto.bool_field(9) + + +@dataclass +class TrainVisitorBehaviorFinishCsReq(betterproto.Message): + visitor_id: int = betterproto.uint32_field(5) + + +@dataclass +class TrainVisitorBehaviorFinishScRsp(betterproto.Message): + visitor_id: int = betterproto.uint32_field(3) + retcode: int = betterproto.uint32_field(15) + reward: "ItemList" = betterproto.message_field(8) + + +@dataclass +class GetTrainVisitorBehaviorCsReq(betterproto.Message): + oifnlnbkdma: List[int] = betterproto.uint32_field(4) + + +@dataclass +class GetTrainVisitorBehaviorScRsp(betterproto.Message): + ecfopdhgkfb: List["TrainVisitorBehavior"] = betterproto.message_field(5) + retcode: int = betterproto.uint32_field(6) + + +@dataclass +class TrainRefreshTimeNotify(betterproto.Message): + akalbjecjik: int = betterproto.uint64_field(4) + + +@dataclass +class TrainVisitorRewardSendNotify(betterproto.Message): + type: "TrainVisitorRewardSendType" = betterproto.enum_field(9) + reward: "ItemList" = betterproto.message_field(8) + visitor_id: int = betterproto.uint32_field(12) + + +@dataclass +class HGLKMJFEHMB(betterproto.Message): + ijabkdepgma: bool = betterproto.bool_field(15) + visitor_id: int = betterproto.uint32_field(1) + edhhgcpdkik: List[int] = betterproto.uint32_field(10) + status: "TrainVisitorStatus" = betterproto.enum_field(6) + opaokgjbooe: int = betterproto.uint32_field(13) + + +@dataclass +class GetTrainVisitorRegisterCsReq(betterproto.Message): + type: "TrainVisitorRegisterGetType" = betterproto.enum_field(1) + + +@dataclass +class GetTrainVisitorRegisterScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(11) + fdmfkaljbaj: List["HGLKMJFEHMB"] = betterproto.message_field(5) + famhpmfoijh: List[int] = betterproto.uint32_field(15) + + +@dataclass +class TakeTrainVisitorUntakenBehaviorRewardCsReq(betterproto.Message): + visitor_id: int = betterproto.uint32_field(8) + + +@dataclass +class TakeTrainVisitorUntakenBehaviorRewardScRsp(betterproto.Message): + edhhgcpdkik: List[int] = betterproto.uint32_field(6) + retcode: int = betterproto.uint32_field(9) + visitor_id: int = betterproto.uint32_field(7) + + +@dataclass +class ShowNewSupplementVisitorCsReq(betterproto.Message): + famhpmfoijh: List[int] = betterproto.uint32_field(6) + + +@dataclass +class ShowNewSupplementVisitorScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(1) + + +@dataclass +class NHBDDINFKOH(betterproto.Message): + iimoplcfhah: int = betterproto.uint32_field(3) + lljaegobhmp: int = betterproto.int32_field(10) + item_id: int = betterproto.uint32_field(11) + unique_id: int = betterproto.uint64_field(12) + ieagbpemflg: int = betterproto.int32_field(2) + kbcdecdnefm: int = betterproto.uint32_field(14) + + +@dataclass +class KCHJHCLJOCK(betterproto.Message): + diphgghfmcp: int = betterproto.uint32_field(1) + cpodejofpdd: int = betterproto.uint32_field(10) + embkicmefco: "DCJAOPDINOI" = betterproto.enum_field(7) + hjbpkcfkhli: List["NHBDDINFKOH"] = betterproto.message_field(8) + clfgfaboiop: "HGKKPPLJBOI" = betterproto.enum_field(4) + + +@dataclass +class TravelBrochureGetDataCsReq(betterproto.Message): + pass + + +@dataclass +class TravelBrochureGetDataScRsp(betterproto.Message): + custom_value: int = betterproto.uint32_field(1) + retcode: int = betterproto.uint32_field(15) + fkbbomhekpe: Dict[int, int] = betterproto.map_field( + 8, betterproto.TYPE_UINT32, betterproto.TYPE_UINT32 + ) + mibclbgmdla: Dict[int, "KCHJHCLJOCK"] = betterproto.map_field( + 14, betterproto.TYPE_UINT32, betterproto.TYPE_MESSAGE + ) + + +@dataclass +class TravelBrochurePageUnlockScNotify(betterproto.Message): + cpodejofpdd: int = betterproto.uint32_field(6) + + +@dataclass +class TravelBrochureSelectMessageCsReq(betterproto.Message): + diphgghfmcp: int = betterproto.uint32_field(10) + cpodejofpdd: int = betterproto.uint32_field(6) + + +@dataclass +class TravelBrochureSelectMessageScRsp(betterproto.Message): + reward: "ItemList" = betterproto.message_field(9) + cagglkliimf: "KCHJHCLJOCK" = betterproto.message_field(13) + retcode: int = betterproto.uint32_field(12) + + +@dataclass +class TravelBrochureApplyPasterCsReq(betterproto.Message): + item_id: int = betterproto.uint32_field(11) + kbcdecdnefm: int = betterproto.uint32_field(12) + iimoplcfhah: int = betterproto.uint32_field(9) + cpodejofpdd: int = betterproto.uint32_field(3) + lljaegobhmp: int = betterproto.int32_field(5) + ieagbpemflg: int = betterproto.int32_field(2) + + +@dataclass +class TravelBrochureApplyPasterScRsp(betterproto.Message): + cagglkliimf: "KCHJHCLJOCK" = betterproto.message_field(4) + retcode: int = betterproto.uint32_field(5) + + +@dataclass +class TravelBrochureRemovePasterCsReq(betterproto.Message): + unique_id: int = betterproto.uint64_field(11) + cpodejofpdd: int = betterproto.uint32_field(4) + item_id: int = betterproto.uint32_field(9) + + +@dataclass +class TravelBrochureRemovePasterScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(3) + cagglkliimf: "KCHJHCLJOCK" = betterproto.message_field(1) + + +@dataclass +class TravelBrochureUpdatePasterPosCsReq(betterproto.Message): + cpodejofpdd: int = betterproto.uint32_field(8) + lljaegobhmp: int = betterproto.int32_field(9) + kbcdecdnefm: int = betterproto.uint32_field(14) + iimoplcfhah: int = betterproto.uint32_field(5) + item_id: int = betterproto.uint32_field(12) + unique_id: int = betterproto.uint64_field(1) + ieagbpemflg: int = betterproto.int32_field(7) + + +@dataclass +class TravelBrochureUpdatePasterPosScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(3) + cagglkliimf: "KCHJHCLJOCK" = betterproto.message_field(6) + + +@dataclass +class TravelBrochureGetPasterScNotify(betterproto.Message): + num: int = betterproto.uint32_field(8) + fkkobdmfhil: int = betterproto.uint32_field(1) + + +@dataclass +class GKDIHIFFHFD(betterproto.Message): + num: int = betterproto.uint32_field(13) + fkkobdmfhil: int = betterproto.uint32_field(3) + + +@dataclass +class TravelBrochureSetCustomValueCsReq(betterproto.Message): + value: int = betterproto.uint32_field(4) + + +@dataclass +class TravelBrochureSetCustomValueScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(12) + + +@dataclass +class TravelBrochureSetPageDescStatusCsReq(betterproto.Message): + cpodejofpdd: int = betterproto.uint32_field(12) + geibgfdenja: "DCJAOPDINOI" = betterproto.enum_field(9) + + +@dataclass +class TravelBrochureSetPageDescStatusScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(15) + + +@dataclass +class TravelBrochurePageResetCsReq(betterproto.Message): + cpodejofpdd: int = betterproto.uint32_field(1) + + +@dataclass +class TravelBrochurePageResetScRsp(betterproto.Message): + cagglkliimf: "KCHJHCLJOCK" = betterproto.message_field(9) + retcode: int = betterproto.uint32_field(7) + + +@dataclass +class KBJPHLNAPGI(betterproto.Message): + iimoplcfhah: int = betterproto.uint32_field(1) + item_id: int = betterproto.uint32_field(7) + kbcdecdnefm: int = betterproto.uint32_field(12) + ieagbpemflg: int = betterproto.int32_field(2) + lljaegobhmp: int = betterproto.int32_field(10) + + +@dataclass +class TravelBrochureApplyPasterListCsReq(betterproto.Message): + cpodejofpdd: int = betterproto.uint32_field(9) + gedglncpggn: List["KBJPHLNAPGI"] = betterproto.message_field(7) + + +@dataclass +class TravelBrochureApplyPasterListScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(6) + cagglkliimf: "KCHJHCLJOCK" = betterproto.message_field(13) + + +@dataclass +class TreasureDungeonRecordData(betterproto.Message): + source_grid_id: int = betterproto.uint32_field(7) + target_grid_id: int = betterproto.uint32_field(10) + param1: int = betterproto.uint32_field(8) + param2: int = betterproto.uint32_field(12) + type: "IMKNBJCOIOP" = betterproto.enum_field(4) + + +@dataclass +class TreasureDungeonDataScNotify(betterproto.Message): + dlejpjjcelj: "KLCKNKLPONM" = betterproto.message_field(5) + + +@dataclass +class TreasureDungeonFinishScNotify(betterproto.Message): + pikapdjhgnd: int = betterproto.uint32_field(7) + kgmmpgfgodj: Dict[int, int] = betterproto.map_field( + 3, betterproto.TYPE_UINT32, betterproto.TYPE_UINT32 + ) + jbcgkldmhnl: Dict[int, int] = betterproto.map_field( + 8, betterproto.TYPE_UINT32, betterproto.TYPE_UINT32 + ) + is_win: bool = betterproto.bool_field(12) + aecncdpjpdg: int = betterproto.uint32_field(13) + hohhbihfjeh: int = betterproto.uint32_field(5) + nlmdemohboo: int = betterproto.uint32_field(4) + + +@dataclass +class KLCKNKLPONM(betterproto.Message): + fcjeckcickb: int = betterproto.uint32_field(12) + avatar_list: List["PCAIGNJKAFA"] = betterproto.message_field(56) + mkoambmkdid: List["LKCMFEAAHHM"] = betterproto.message_field(11) + phhkbaenbmm: int = betterproto.uint32_field(14) + pikapdjhgnd: int = betterproto.uint32_field(13) + map_id: int = betterproto.uint32_field(9) + item_list: List["LHANBGNJCIF"] = betterproto.message_field(1002) + nodbpkhojec: bool = betterproto.bool_field(885) + bbckfjihidm: List["TreasureDungeonRecordData"] = betterproto.message_field(3) + ncbhadloaga: int = betterproto.uint32_field(8) + cfdpdenppdh: bool = betterproto.bool_field(121) + iialglddnad: int = betterproto.uint32_field(363) + gffojccklfm: List["PCAIGNJKAFA"] = betterproto.message_field(268) + nmfapgolodj: bool = betterproto.bool_field(1435) + buff_list: List["ENBNFOLCDIE"] = betterproto.message_field(36) + jafnpnmohcm: int = betterproto.uint32_field(6) + kjjomephjee: List["LKHHGJPPMPP"] = betterproto.message_field(1232) + nlmdemohboo: int = betterproto.uint32_field(4) + + +@dataclass +class LHANBGNJCIF(betterproto.Message): + item_count: int = betterproto.uint32_field(1) + item_id: int = betterproto.uint32_field(7) + + +@dataclass +class PCAIGNJKAFA(betterproto.Message): + hp: int = betterproto.uint32_field(4) + avatar_type: int = betterproto.uint32_field(7) + sp_bar: "SpBarInfo" = betterproto.message_field(10) + eajljnbnpnp: int = betterproto.uint32_field(14) + avatar_id: int = betterproto.uint32_field(1) + + +@dataclass +class LKHHGJPPMPP(betterproto.Message): + avatar_id: int = betterproto.uint32_field(3) + avatar_type: int = betterproto.uint32_field(1) + + +@dataclass +class ENBNFOLCDIE(betterproto.Message): + akahnmlnefn: int = betterproto.uint32_field(9) + buff_id: int = betterproto.uint32_field(12) + + +@dataclass +class LKCMFEAAHHM(betterproto.Message): + hemjhdoeebl: bool = betterproto.bool_field(3) + demncglljcp: bool = betterproto.bool_field(7) + buff_list: List["GGGCOCPGBBH"] = betterproto.message_field(1329) + monhibbpkee: int = betterproto.uint32_field(11) + knlfeldecal: bool = betterproto.bool_field(12) + ollhobhdden: int = betterproto.uint32_field(4) + limmileapjm: bool = betterproto.bool_field(13) + hfnhlcfnhkd: int = betterproto.uint32_field(1) + + +@dataclass +class GGGCOCPGBBH(betterproto.Message): + leaaebafchp: int = betterproto.uint32_field(11) + ecghnfccbjj: int = betterproto.uint32_field(12) + hfnhlcfnhkd: int = betterproto.uint32_field(6) + buff_id: int = betterproto.uint32_field(3) + egkdinmmena: int = betterproto.uint32_field(1) + + +@dataclass +class ABHFABFGPOF(betterproto.Message): + fcjeckcickb: int = betterproto.uint32_field(7) + nlmdemohboo: int = betterproto.uint32_field(9) + cloonoifefo: bool = betterproto.bool_field(5) + jafnpnmohcm: int = betterproto.uint32_field(3) + pikapdjhgnd: int = betterproto.uint32_field(12) + biinncndpcg: bool = betterproto.bool_field(4) + nkhkdjkegdh: int = betterproto.uint32_field(13) + + +@dataclass +class GetTreasureDungeonActivityDataCsReq(betterproto.Message): + pass + + +@dataclass +class GetTreasureDungeonActivityDataScRsp(betterproto.Message): + hiookmoandn: List["ABHFABFGPOF"] = betterproto.message_field(9) + retcode: int = betterproto.uint32_field(6) + + +@dataclass +class EnterTreasureDungeonCsReq(betterproto.Message): + avatar_list: List["JACKEJLKJNA"] = betterproto.message_field(8) + nlmdemohboo: int = betterproto.uint32_field(11) + + +@dataclass +class EnterTreasureDungeonScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(2) + dlejpjjcelj: "KLCKNKLPONM" = betterproto.message_field(6) + + +@dataclass +class OpenTreasureDungeonGridCsReq(betterproto.Message): + hfnhlcfnhkd: int = betterproto.uint32_field(7) + nlmdemohboo: int = betterproto.uint32_field(5) + + +@dataclass +class OpenTreasureDungeonGridScRsp(betterproto.Message): + retcode: int = betterproto.uint32_field(7) + dlejpjjcelj: "KLCKNKLPONM" = betterproto.message_field(6) + + +# @dataclass +# class InteractTreasureDungeonGridCsReq(betterproto.Message): +# hfnhlcfnhkd: int = betterproto.uint32_field(4) +# display_value: int = betterproto.uint32_field(6) +# nlmdemohboo: int = betterproto.uint32_field(12) + + +# @dataclass +# class InteractTreasureDungeonGridScRsp(betterproto.Message): +# dlejpjjcelj: "KLCKNKLPONM" = betterproto.message_field(9) +# retcode: int = betterproto.uint32_field(3) + + +# @dataclass +# class UseTreasureDungeonItemCsReq(betterproto.Message): +# item_id: int = betterproto.uint32_field(7) +# hfnhlcfnhkd: int = betterproto.uint32_field(3) +# nlmdemohboo: int = betterproto.uint32_field(14) + + +# @dataclass +# class UseTreasureDungeonItemScRsp(betterproto.Message): +# retcode: int = betterproto.uint32_field(11) +# dlejpjjcelj: "KLCKNKLPONM" = betterproto.message_field(15) + + +# @dataclass +# class JACKEJLKJNA(betterproto.Message): +# avatar_id: int = betterproto.uint32_field(10) +# avatar_type: "AvatarType" = betterproto.enum_field(14) + + +# @dataclass +# class FightTreasureDungeonMonsterCsReq(betterproto.Message): +# hfnhlcfnhkd: int = betterproto.uint32_field(13) +# avatar_list: List["JACKEJLKJNA"] = betterproto.message_field(11) +# nlmdemohboo: int = betterproto.uint32_field(14) + + +# @dataclass +# class FightTreasureDungeonMonsterScRsp(betterproto.Message): +# battle_info: "SceneBattleInfo" = betterproto.message_field(8) +# retcode: int = betterproto.uint32_field(9) + + +# @dataclass +# class QuitTreasureDungeonCsReq(betterproto.Message): +# nlmdemohboo: int = betterproto.uint32_field(6) +# pcpdfjhdjcc: bool = betterproto.bool_field(1) + + +# @dataclass +# class QuitTreasureDungeonScRsp(betterproto.Message): +# retcode: int = betterproto.uint32_field(2) + + +# @dataclass +# class Tutorial(betterproto.Message): +# id: int = betterproto.uint32_field(8) +# status: "TutorialStatus" = betterproto.enum_field(3) + + +# @dataclass +# class TutorialGuide(betterproto.Message): +# status: "TutorialStatus" = betterproto.enum_field(6) +# id: int = betterproto.uint32_field(7) + + +# @dataclass +# class GetTutorialCsReq(betterproto.Message): +# pass + + +# @dataclass +# class GetTutorialScRsp(betterproto.Message): +# retcode: int = betterproto.uint32_field(11) +# tutorial_list: List["Tutorial"] = betterproto.message_field(9) + + +# @dataclass +# class GetTutorialGuideCsReq(betterproto.Message): +# pass + + +# @dataclass +# class GetTutorialGuideScRsp(betterproto.Message): +# retcode: int = betterproto.uint32_field(7) +# tutorial_guide_list: List["TutorialGuide"] = betterproto.message_field(5) + + +# @dataclass +# class UnlockTutorialCsReq(betterproto.Message): +# tutorial_id: int = betterproto.uint32_field(7) + + +# @dataclass +# class UnlockTutorialScRsp(betterproto.Message): +# tutorial: "Tutorial" = betterproto.message_field(10) +# retcode: int = betterproto.uint32_field(15) + + +# @dataclass +# class UnlockTutorialGuideCsReq(betterproto.Message): +# group_id: int = betterproto.uint32_field(7) + + +# @dataclass +# class UnlockTutorialGuideScRsp(betterproto.Message): +# retcode: int = betterproto.uint32_field(3) +# tutorial_guide: "TutorialGuide" = betterproto.message_field(15) + + +# @dataclass +# class FinishTutorialCsReq(betterproto.Message): +# tutorial_id: int = betterproto.uint32_field(15) + + +# @dataclass +# class FinishTutorialScRsp(betterproto.Message): +# retcode: int = betterproto.uint32_field(12) +# tutorial: "Tutorial" = betterproto.message_field(3) + + +# @dataclass +# class FinishTutorialGuideCsReq(betterproto.Message): +# group_id: int = betterproto.uint32_field(8) + + +# @dataclass +# class FinishTutorialGuideScRsp(betterproto.Message): +# reward: "ItemList" = betterproto.message_field(3) +# tutorial_guide: "TutorialGuide" = betterproto.message_field(6) +# retcode: int = betterproto.uint32_field(12) + + +# @dataclass +# class Waypoint(betterproto.Message): +# khfgdkngfdp: int = betterproto.uint32_field(9) +# id: int = betterproto.uint32_field(14) +# is_new: bool = betterproto.bool_field(6) + + +# @dataclass +# class ChapterBrief(betterproto.Message): +# is_new: bool = betterproto.bool_field(14) +# taken_reward_id_list: List[int] = betterproto.uint32_field(15) +# nckelkegbgl: int = betterproto.uint32_field(8) +# id: int = betterproto.uint32_field(11) + + +# @dataclass +# class Chapter(betterproto.Message): +# konbfjpinhn: List["Waypoint"] = betterproto.message_field(5) +# gokhjlmpnff: "ChapterBrief" = betterproto.message_field(11) + + +# @dataclass +# class GetWaypointCsReq(betterproto.Message): +# kiekjeffphk: int = betterproto.uint32_field(15) + + +# @dataclass +# class GetWaypointScRsp(betterproto.Message): +# fjjflkcmidj: "Chapter" = betterproto.message_field(9) +# retcode: int = betterproto.uint32_field(13) +# hoeahbifkci: int = betterproto.uint32_field(15) + + +# @dataclass +# class SetCurWaypointCsReq(betterproto.Message): +# nkcmnafaioi: int = betterproto.uint32_field(13) + + +# @dataclass +# class SetCurWaypointScRsp(betterproto.Message): +# retcode: int = betterproto.uint32_field(15) +# hoeahbifkci: int = betterproto.uint32_field(4) \ No newline at end of file diff --git a/sdk_server/__init__.py b/sdk_server/__init__.py new file mode 100644 index 0000000..ade4890 --- /dev/null +++ b/sdk_server/__init__.py @@ -0,0 +1,44 @@ +import logging +from flask import Flask +from sdk_server.controllers.config.agreement_controller import agreement_blueprint +from sdk_server.controllers.config.alert_ann_controller import alert_ann_blueprint +from sdk_server.controllers.config.alert_pict_controller import alert_pic_blueprint +from sdk_server.controllers.config.batch_upload_controller import batch_upload_blueprint +from sdk_server.controllers.config.combo_config_controller import combo_config_blueprint +from sdk_server.controllers.config.combo_controller import combo_blueprint +from sdk_server.controllers.config.compare_protocol_ver_controller import compare_protocol_ver_blueprint +from sdk_server.controllers.config.data_upload_controller import data_upload_blueprint +from sdk_server.controllers.config.risky_check_controller import risky_check_blueprint +from sdk_server.controllers.login.login_controller import login_blueprint +from sdk_server.controllers.login.login_v2_controller import login_v2_blueprint +from sdk_server.controllers.login.query_dispatch_controller import query_dispatch_blueprint +from sdk_server.controllers.login.query_gateway_controller import query_gateway_blueprint +from sdk_server.controllers.login.token_login_controller import token_login_blueprint + + +app = Flask(__name__) + +log = logging.getLogger('werkzeug') +log.setLevel(logging.ERROR) + +# CONFIG +app.register_blueprint(agreement_blueprint) +app.register_blueprint(alert_ann_blueprint) +app.register_blueprint(alert_pic_blueprint) +app.register_blueprint(batch_upload_blueprint) +app.register_blueprint(combo_config_blueprint) +app.register_blueprint(combo_blueprint) +app.register_blueprint(compare_protocol_ver_blueprint) +app.register_blueprint(data_upload_blueprint) +app.register_blueprint(risky_check_blueprint) + +# LOGIN +app.register_blueprint(login_blueprint) +app.register_blueprint(login_v2_blueprint) +app.register_blueprint(query_dispatch_blueprint) +app.register_blueprint(query_gateway_blueprint) +app.register_blueprint(token_login_blueprint) + +def run_http_server(host, port): + app.run(host=host, port=port, debug=False) + diff --git a/sdk_server/controllers/config/agreement_controller.py b/sdk_server/controllers/config/agreement_controller.py new file mode 100644 index 0000000..13a8ddf --- /dev/null +++ b/sdk_server/controllers/config/agreement_controller.py @@ -0,0 +1,16 @@ +from flask import Blueprint, jsonify +from sdk_server.models.config.agreement_data import AgreementInfoRsp + +agreement_blueprint = Blueprint('agreement', __name__) + +@agreement_blueprint.route('/hkrpg_cn/mdk/agreement/api/getAgreementInfos', methods=['GET']) +@agreement_blueprint.route('/hkrpg_global/mdk/agreement/api/getAgreementInfos', methods=['GET']) +def agreement(): + response_data = AgreementInfoRsp( + retcode=0, + message="OK", + data=AgreementInfoRsp.Data( + marketing_agreements=[] + ) + ) + return jsonify(response_data.model_dump()) \ No newline at end of file diff --git a/sdk_server/controllers/config/alert_ann_controller.py b/sdk_server/controllers/config/alert_ann_controller.py new file mode 100644 index 0000000..79fd2ee --- /dev/null +++ b/sdk_server/controllers/config/alert_ann_controller.py @@ -0,0 +1,19 @@ +from flask import Blueprint, jsonify +from sdk_server.models.config.alert_ann_data import AlertAnnRsp + +alert_ann_blueprint = Blueprint('alert_ann', __name__) + +@alert_ann_blueprint.route('/common/hkrpg_cn/announcement/api/getAlertAnn', methods=['GET']) +@alert_ann_blueprint.route('/common/hkrpg_global/announcement/api/getAlertAnn', methods=['GET']) +def alert_ann(): + response_data = AlertAnnRsp( + retcode=0, + message="OK", + data=AlertAnnRsp.Data( + alert=False, + alert_id=0, + remind=True, + extra_remind=True + ) + ) + return jsonify(response_data.model_dump()) \ No newline at end of file diff --git a/sdk_server/controllers/config/alert_pict_controller.py b/sdk_server/controllers/config/alert_pict_controller.py new file mode 100644 index 0000000..4886a25 --- /dev/null +++ b/sdk_server/controllers/config/alert_pict_controller.py @@ -0,0 +1,17 @@ +from flask import Blueprint, jsonify +from sdk_server.models.config.alert_pic_data import AlertPicRsp + +alert_pic_blueprint = Blueprint('alert_pic', __name__) + +@alert_pic_blueprint.route('/common/hkrpg_cn/announcement/api/getAlertPic', methods=['GET']) +@alert_pic_blueprint.route('/common/hkrpg_global/announcement/api/getAlertPic', methods=['GET']) +def alert_pic(): + response_data = AlertPicRsp( + retcode=0, + message="OK", + data=AlertPicRsp.Data( + total=0, + list=[] + ) + ) + return jsonify(response_data.model_dump()) \ No newline at end of file diff --git a/sdk_server/controllers/config/batch_upload_controller.py b/sdk_server/controllers/config/batch_upload_controller.py new file mode 100644 index 0000000..f8773fd --- /dev/null +++ b/sdk_server/controllers/config/batch_upload_controller.py @@ -0,0 +1,13 @@ +from flask import Blueprint, jsonify +from sdk_server.models.config.batch_upload_data import BatchUploadRsp + +batch_upload_blueprint = Blueprint('batch_upload', __name__) + +@batch_upload_blueprint.route('/common/h5log/log/batch', methods=['POST']) +def batch_upload(): + response_data = BatchUploadRsp( + retcode=0, + message="success", + data=[] + ) + return jsonify(response_data.model_dump()) \ No newline at end of file diff --git a/sdk_server/controllers/config/combo_config_controller.py b/sdk_server/controllers/config/combo_config_controller.py new file mode 100644 index 0000000..6a0ccc5 --- /dev/null +++ b/sdk_server/controllers/config/combo_config_controller.py @@ -0,0 +1,35 @@ +from flask import Blueprint, jsonify +from sdk_server.models.config.combo_config_data import ComboConfigRsp,QrEnabledApps,QrAppIcons + +combo_config_blueprint = Blueprint('combo_config', __name__) + +@combo_config_blueprint.route('/hkrpg_cn/combo/granter/api/getConfig', methods=['GET']) +@combo_config_blueprint.route('/hkrpg_global/combo/granter/api/getConfig', methods=['GET']) +def combo_config(): + response_data = ComboConfigRsp( + retcode=0, + message="OK", + data=ComboConfigRsp.Data( + protocol = True, + qr_enabled = False, + log_level = "INFO", + announce_url = "", + push_alias_type = 0, + disable_ysdk_guard = True, + enable_announce_pic_popup = False, + app_name = "崩坏RPG", + qr_enabled_apps=QrEnabledApps( + bbs=False, + cloud=False + ), + qr_app_icons=QrAppIcons( + app="", + bbs="", + cloud="" + ), + qr_cloud_display_name="", + enable_user_center=False, + functional_switch_configs=[] + ) + ) + return jsonify(response_data.model_dump()) \ No newline at end of file diff --git a/sdk_server/controllers/config/combo_controller.py b/sdk_server/controllers/config/combo_controller.py new file mode 100644 index 0000000..bc8364c --- /dev/null +++ b/sdk_server/controllers/config/combo_controller.py @@ -0,0 +1,51 @@ +from flask import Blueprint, jsonify +from sdk_server.models.config.combo_data import ( + ComboRsp, + KibanaPc, + Report, + Telemetry, + LogFilter, + RenderMethod, + Function +) + +combo_blueprint = Blueprint('combo', __name__) + +@combo_blueprint.route('/combo/box/api/config/sdk/combo', methods=['GET']) +def combo(): + response_data = ComboRsp( + vals=ComboRsp.Values( + kibana_pc_config=KibanaPc( + enable=1, + level="Info", + modules=["download"] + ), + network_report_config=Report( + enable=1, + status_codes=[206], + url_paths=["dataUpload", "red_dot"] + ), + modify_real_name_other_verify=True, + telemetry_config=Telemetry( + dataupload_enable=1 + ), + enable_web_dpi=True, + h5log_filter_config=LogFilter( + function=Function( + event_name=[ + "info_get_cps", + "notice_close_notice", + "info_get_uapc", + "report_set_info", + "info_get_channel_id", + "info_get_sub_channel_id" + ] + ) + ), + webview_rendermethod_config=RenderMethod( + use_legacy=True + ), + list_price_tierv2_enable=True + ) + ) + return jsonify(response_data.model_dump()) \ No newline at end of file diff --git a/sdk_server/controllers/config/compare_protocol_ver_controller.py b/sdk_server/controllers/config/compare_protocol_ver_controller.py new file mode 100644 index 0000000..9ea530c --- /dev/null +++ b/sdk_server/controllers/config/compare_protocol_ver_controller.py @@ -0,0 +1,17 @@ +from flask import Blueprint, jsonify +from sdk_server.models.config.compare_protocol_ver_data import CompareProtocolVerRsp + +compare_protocol_ver_blueprint = Blueprint('compare_protocol_ver', __name__) + +@compare_protocol_ver_blueprint.route('/hkrpg_cn/combo/granter/api/compareProtocolVersion', methods=['POST']) +@compare_protocol_ver_blueprint.route('/hkrpg_global/combo/granter/api/compareProtocolVersion', methods=['POST']) +def compare_protocol_ver(): + response_data = CompareProtocolVerRsp( + retcode=0, + message="OK", + data=CompareProtocolVerRsp.Data( + modified=False, + protocol=[] + ) + ) + return jsonify(response_data.model_dump()) \ No newline at end of file diff --git a/sdk_server/controllers/config/data_upload_controller.py b/sdk_server/controllers/config/data_upload_controller.py new file mode 100644 index 0000000..8f4bbb3 --- /dev/null +++ b/sdk_server/controllers/config/data_upload_controller.py @@ -0,0 +1,12 @@ +from flask import Blueprint, jsonify +from sdk_server.models.config.log_upload_data import LogUploadRsp + +data_upload_blueprint = Blueprint('data_upload', __name__) + +@data_upload_blueprint.route('/sdk/dataUpload', methods=['POST']) +@data_upload_blueprint.route('/loginsdk/dataUpload', methods=['POST']) +@data_upload_blueprint.route('/crashdump/dataUpload', methods=['POST']) +@data_upload_blueprint.route('/apm/dataUpload', methods=['POST']) +def data_upload(): + response_data = LogUploadRsp(code=0) + return jsonify(response_data.model_dump()) \ No newline at end of file diff --git a/sdk_server/controllers/config/risky_check_controller.py b/sdk_server/controllers/config/risky_check_controller.py new file mode 100644 index 0000000..19f8928 --- /dev/null +++ b/sdk_server/controllers/config/risky_check_controller.py @@ -0,0 +1,17 @@ +from flask import Blueprint, jsonify +from sdk_server.models.config.risky_check_data import RiskyCheckRsp + +risky_check_blueprint = Blueprint('risky_check', __name__) + +@risky_check_blueprint.route('/account/risky/api/check', methods=['POST']) +def risky_check(): + response_data = RiskyCheckRsp( + retcode=0, + message="OK", + data=RiskyCheckRsp.Data( + id="none", + action="ACTION_NONE", + geetest={} + ) + ) + return jsonify(response_data.model_dump()) \ No newline at end of file diff --git a/sdk_server/controllers/login/login_controller.py b/sdk_server/controllers/login/login_controller.py new file mode 100644 index 0000000..64a3ffe --- /dev/null +++ b/sdk_server/controllers/login/login_controller.py @@ -0,0 +1,42 @@ +from flask import Blueprint, jsonify, request +from database.account.account_data import create_new_account +from sdk_server.models.login.login_data import LoginReq,LoginRsp,Account +from database.account.account_data import find_account_by_name + +login_blueprint = Blueprint('login', __name__) + +@login_blueprint.route('/hkrpg_cn/mdk/shield/api/login', methods=['POST']) +@login_blueprint.route('/hkrpg_global/mdk/shield/api/login', methods=['POST']) +@login_blueprint.route('/account/ma-cn-passport/app/loginByPassword', methods=['POST']) +def login(): + body=request.get_json() + try: + login_req = LoginReq(**body) + except Exception as e: + return jsonify({"error": "Invalid input", "details": str(e)}), 400 + account_data=find_account_by_name(login_req.account) + if not account_data: + create_new_account(login_req.account) + account_data=find_account_by_name(login_req.account) + + rsp=LoginRsp( + retcode=0, + message="success", + data=LoginRsp.Data( + account=Account( + uid=str(account_data.id), + name=account_data.username + "@MikuMiku", + token=account_data.token, + is_email_verify=0, + realname="Miku", + identity_card="114514", + country="OS", + area_code="OS", + ), + device_grant_required=False, + realname_operation="NONE", + realperson_required=False, + safe_mobile_required=False + ) + ) + return jsonify(rsp.model_dump()) \ No newline at end of file diff --git a/sdk_server/controllers/login/login_v2_controller.py b/sdk_server/controllers/login/login_v2_controller.py new file mode 100644 index 0000000..5d42fe4 --- /dev/null +++ b/sdk_server/controllers/login/login_v2_controller.py @@ -0,0 +1,36 @@ +import json +from flask import Blueprint, jsonify, request +from utils.crypto import generate_combo_token +from sdk_server.models.login.login_v2_data import LoginV2Req,LoginV2Rsp +from database.account.account_data import find_account_by_uid + +login_v2_blueprint = Blueprint('login_v2', __name__) + +@login_v2_blueprint.route('/hkrpg_cn/combo/granter/login/v2/login', methods=['POST']) +@login_v2_blueprint.route('/hkrpg_global/combo/granter/login/v2/login', methods=['POST']) +def login_v2(): + res=LoginV2Rsp() + body=request.json + login_v2_req=LoginV2Req(**body) + data_dict = json.loads(login_v2_req.data) + token_data = LoginV2Req.Data(**data_dict) + if not token_data: + res.retcode=0 + res.message="Invalid login data" + return jsonify(res.model_dump()) + + account_data=find_account_by_uid(int(token_data.uid)) + if not account_data: + res.retcode=-201 + res.message="Game account cache information error" + return jsonify(res.model_dump()) + + res.message="OK" + res.data=LoginV2Rsp.Data( + account_type=1, + open_id=str(account_data.id), + combo_token=generate_combo_token(str(account_data.id)), + data="{\"guest\":false}" + ) + return jsonify(res.model_dump()) + diff --git a/sdk_server/controllers/login/query_dispatch_controller.py b/sdk_server/controllers/login/query_dispatch_controller.py new file mode 100644 index 0000000..7e67c1d --- /dev/null +++ b/sdk_server/controllers/login/query_dispatch_controller.py @@ -0,0 +1,20 @@ +import base64 +from flask import Blueprint +from rail_proto.lib import Dispatch,RegionInfo + +query_dispatch_blueprint = Blueprint('query_dispatch', __name__) + +@query_dispatch_blueprint.route("/query_dispatch", methods=["GET"]) +def query_dispatch(): + rsp = Dispatch( + retcode=0, + region_list=[ + RegionInfo( + name="NeonSR", + title="NeonSR", + env_type="21", + dispatch_url="http://127.0.0.1:21000/query_gateway", + ) + ] + ) + return base64.b64encode(rsp.SerializeToString()).decode() \ No newline at end of file diff --git a/sdk_server/controllers/login/query_gateway_controller.py b/sdk_server/controllers/login/query_gateway_controller.py new file mode 100644 index 0000000..40628b3 --- /dev/null +++ b/sdk_server/controllers/login/query_gateway_controller.py @@ -0,0 +1,45 @@ +import base64 +import json +from flask import Blueprint,request +from rail_proto.lib import GateServer + +query_gateway_blueprint = Blueprint('query_gateway', __name__) + +@query_gateway_blueprint.route("/query_gateway", methods=["GET"]) +def query_gateway(): + version = request.args.get('version') + with open('version.json', 'r') as f: + reader = json.load(f) + config = reader.get(version) + if config: + rsp = GateServer( + retcode=0, + ip="127.0.0.1", + port=23301, + asset_bundle_url="", + lua_url="", + ex_resource_url="", + mdk_res_version="", + enable_version_update=True, + enable_design_data_version_update=True, + enable_save_replay_file=True, + enable_upload_battle_log=True, + enable_watermark=True, + event_tracking_open=True, + ) + else: + rsp = GateServer( + retcode=0, + ip="127.0.0.1", + port=23301, + asset_bundle_url="", + lua_url="", + ex_resource_url="", + enable_version_update=True, + enable_design_data_version_update=True, + enable_save_replay_file=True, + enable_upload_battle_log=True, + enable_watermark=True, + event_tracking_open=True, + ) + return base64.b64encode(rsp.SerializeToString()).decode() \ No newline at end of file diff --git a/sdk_server/controllers/login/token_login_controller.py b/sdk_server/controllers/login/token_login_controller.py new file mode 100644 index 0000000..252017f --- /dev/null +++ b/sdk_server/controllers/login/token_login_controller.py @@ -0,0 +1,40 @@ +from flask import Blueprint, jsonify, request +from sdk_server.models.login.token_login_data import TokenLoginReq +from sdk_server.models.login.login_data import LoginRsp,Account + +from database.account.account_data import find_account_by_uid + +token_login_blueprint = Blueprint('token_login', __name__) + +@token_login_blueprint.route('/hkrpg_cn/mdk/shield/api/verify', methods=['POST']) +@token_login_blueprint.route('/hkrpg_global/mdk/shield/api/verify', methods=['POST']) +@token_login_blueprint.route('/account/ma-cn-session/app/verify', methods=['POST']) +def token_login(): + res=LoginRsp() + body=request.json + req=TokenLoginReq(**body) + account_data=find_account_by_uid(int(req.uid)) + if not account_data or account_data.token != req.token: + res.retcode=0 + res.message="Game account cache information error" + else: + res.retcode=0 + res.message="OK" + res.data=LoginRsp.Data( + account=Account( + uid=str(account_data.id), + name=account_data.username + "@MikuMiku", + token=account_data.token, + is_email_verify=0, + realname="Miku", + identity_card="114514", + country="OS", + area_code="OS", + ), + device_grant_required=False, + realname_operation="NONE", + realperson_required=False, + safe_mobile_required=False + ) + return jsonify(res.model_dump()) + diff --git a/sdk_server/models/config/agreement_data.py b/sdk_server/models/config/agreement_data.py new file mode 100644 index 0000000..5e370a7 --- /dev/null +++ b/sdk_server/models/config/agreement_data.py @@ -0,0 +1,9 @@ +from pydantic import BaseModel +from typing import List, Optional +from sdk_server.models.config.response_base import ResponseBase + +class AgreementInfoRsp(ResponseBase): + class Data(BaseModel): + marketing_agreements: Optional[List[str]] = [] + + data: Optional[Data] = None \ No newline at end of file diff --git a/sdk_server/models/config/alert_ann_data.py b/sdk_server/models/config/alert_ann_data.py new file mode 100644 index 0000000..5239bf8 --- /dev/null +++ b/sdk_server/models/config/alert_ann_data.py @@ -0,0 +1,12 @@ +from pydantic import BaseModel +from typing import Optional +from sdk_server.models.config.response_base import ResponseBase + +class AlertAnnRsp(ResponseBase): + class Data(BaseModel): + alert : bool + alert_id: int + remind: bool + extra_remind: bool + + data: Optional[Data] = None \ No newline at end of file diff --git a/sdk_server/models/config/alert_pic_data.py b/sdk_server/models/config/alert_pic_data.py new file mode 100644 index 0000000..c521cb7 --- /dev/null +++ b/sdk_server/models/config/alert_pic_data.py @@ -0,0 +1,10 @@ +from pydantic import BaseModel +from typing import Optional,List +from sdk_server.models.config.response_base import ResponseBase + +class AlertPicRsp(ResponseBase): + class Data(BaseModel): + total : bool + list: Optional[List[str]] = [] + + data: Optional[Data] = None \ No newline at end of file diff --git a/sdk_server/models/config/batch_upload_data.py b/sdk_server/models/config/batch_upload_data.py new file mode 100644 index 0000000..01fa924 --- /dev/null +++ b/sdk_server/models/config/batch_upload_data.py @@ -0,0 +1,6 @@ +from pydantic import BaseModel +from typing import List, Optional +from sdk_server.models.config.response_base import ResponseBase + +class BatchUploadRsp(ResponseBase): + data:Optional[List] = [] \ No newline at end of file diff --git a/sdk_server/models/config/combo_config_data.py b/sdk_server/models/config/combo_config_data.py new file mode 100644 index 0000000..157f4e8 --- /dev/null +++ b/sdk_server/models/config/combo_config_data.py @@ -0,0 +1,32 @@ +from pydantic import BaseModel +from typing import Optional,List +from sdk_server.models.config.response_base import ResponseBase + +class QrEnabledApps(BaseModel): + bbs: bool + cloud: bool + +class QrAppIcons(BaseModel): + app: Optional[str] = None + bbs: Optional[str] = None + cloud: Optional[str] = None + +class ComboConfigRsp(ResponseBase): + class Data(BaseModel): + protocol: bool + qr_enabled: bool + log_level: Optional[str] = None + announce_url: Optional[str] = None + push_alias_type: int + disable_ysdk_guard: bool + enable_announce_pic_popup: bool + app_name: Optional[str] = None + qr_enabled_apps: Optional[QrEnabledApps] = None + qr_app_icons: Optional[QrAppIcons] = None + qr_cloud_display_name: Optional[str] = None + enable_user_center: bool + functional_switch_configs: Optional[List[str]] = None + + data: Optional[Data] = None + + \ No newline at end of file diff --git a/sdk_server/models/config/combo_data.py b/sdk_server/models/config/combo_data.py new file mode 100644 index 0000000..d3600e3 --- /dev/null +++ b/sdk_server/models/config/combo_data.py @@ -0,0 +1,44 @@ +from pydantic import BaseModel +from typing import Optional, List +from sdk_server.models.config.response_base import ResponseBase + +class KibanaPc(BaseModel): + enable: int + level: Optional[str] = None + modules: Optional[List[str]] = None + +class Report(BaseModel): + enable: int + status_codes: Optional[List[int]] = None + url_paths: Optional[List[str]] = None + +class Telemetry(BaseModel): + dataupload_enable: int + +class Function(BaseModel): + event_name: Optional[List[str]] = None + +class LogFilter(BaseModel): + function: Optional[Function] = None + +class RenderMethod(BaseModel): + use_legacy: bool + +class ComboRsp(BaseModel): + class Values(BaseModel): + kibana_pc_config: Optional[KibanaPc] = None + network_report_config: Optional[Report] = None + modify_real_name_other_verify: bool + telemetry_config: Optional[Telemetry] = None + enable_web_dpi: bool + h5log_filter_config: Optional[LogFilter] = None + webview_rendermethod_config: Optional[RenderMethod] = None + list_price_tierv2_enable: bool + + vals: Optional[Values] = None + + + + + + diff --git a/sdk_server/models/config/compare_protocol_ver_data.py b/sdk_server/models/config/compare_protocol_ver_data.py new file mode 100644 index 0000000..b460a33 --- /dev/null +++ b/sdk_server/models/config/compare_protocol_ver_data.py @@ -0,0 +1,10 @@ +from pydantic import BaseModel +from typing import List, Optional +from sdk_server.models.config.response_base import ResponseBase + +class CompareProtocolVerRsp(ResponseBase): + class Data(BaseModel): + modified: bool + protocol: Optional[List[str]] = [] + + data: Optional[Data] = None \ No newline at end of file diff --git a/sdk_server/models/config/finger_print_data.py b/sdk_server/models/config/finger_print_data.py new file mode 100644 index 0000000..13835cd --- /dev/null +++ b/sdk_server/models/config/finger_print_data.py @@ -0,0 +1,13 @@ +from pydantic import BaseModel +from typing import Optional +from sdk_server.models.config.response_base import ResponseBase + +class FingerprintRsp(ResponseBase): + class Data(BaseModel): + device_fp: Optional[str] = None + msg: Optional[str] = None + code: int + + data: Optional[Data] = None + + diff --git a/sdk_server/models/config/log_upload_data.py b/sdk_server/models/config/log_upload_data.py new file mode 100644 index 0000000..2ccc0b6 --- /dev/null +++ b/sdk_server/models/config/log_upload_data.py @@ -0,0 +1,4 @@ +from pydantic import BaseModel + +class LogUploadRsp(BaseModel): + code: int \ No newline at end of file diff --git a/sdk_server/models/config/response_base.py b/sdk_server/models/config/response_base.py new file mode 100644 index 0000000..cc876b8 --- /dev/null +++ b/sdk_server/models/config/response_base.py @@ -0,0 +1,6 @@ +from pydantic import BaseModel +from typing import Optional + +class ResponseBase(BaseModel): + retcode: int = 0 + message: Optional[str] = None \ No newline at end of file diff --git a/sdk_server/models/config/risky_check_data.py b/sdk_server/models/config/risky_check_data.py new file mode 100644 index 0000000..d0561b0 --- /dev/null +++ b/sdk_server/models/config/risky_check_data.py @@ -0,0 +1,12 @@ +from pydantic import BaseModel +from typing import Optional, Any +from sdk_server.models.config.response_base import ResponseBase + + +class RiskyCheckRsp(ResponseBase): + data: Optional["Data"] = None + + class Data(BaseModel): + id: Optional[str] = None + action: Optional[str] = None + geetest: Optional[Any] = None diff --git a/sdk_server/models/login/login_data.py b/sdk_server/models/login/login_data.py new file mode 100644 index 0000000..ba3c8ae --- /dev/null +++ b/sdk_server/models/login/login_data.py @@ -0,0 +1,44 @@ +from pydantic import BaseModel +from typing import Optional +from sdk_server.models.config.response_base import ResponseBase + +class Account(BaseModel): + uid: Optional[str] = None + name: Optional[str] = None + email: Optional[str] = None + mobile: Optional[str] = None + is_email_verify: int + realname: Optional[str] = None + identity_card: Optional[str] = None + token: Optional[str] = None + safe_mobile: Optional[str] = None + facebook_name: Optional[str] = None + twitter_name: Optional[str] = None + game_center_name: Optional[str] = None + google_name: Optional[str] = None + apple_name: Optional[str] = None + sony_name: Optional[str] = None + tap_name: Optional[str] = None + country: Optional[str] = None + reactivate_ticket: Optional[str] = None + area_code: Optional[str] = None + device_grant_ticket: Optional[str] = None + +class LoginReq(BaseModel): + account: Optional[str] = None + password: Optional[str] = None + is_crypto: bool + +class LoginRsp(ResponseBase): + class Data(BaseModel): + account: Optional[Account] = None + device_grant_required: bool + realname_operation: Optional[str] = None + realperson_required: bool + safe_mobile_required: bool + + data: Optional[Data] = None + + + + \ No newline at end of file diff --git a/sdk_server/models/login/login_v2_data.py b/sdk_server/models/login/login_v2_data.py new file mode 100644 index 0000000..0770d19 --- /dev/null +++ b/sdk_server/models/login/login_v2_data.py @@ -0,0 +1,29 @@ +from pydantic import BaseModel +from typing import Optional +from sdk_server.models.config.response_base import ResponseBase + + +class LoginV2Req(BaseModel): + app_id: int + channel_id: int + data: Optional[str] = None + device: Optional[str] = None + sign: Optional[str] = None + + class Data(BaseModel): + uid: Optional[str] = None + token: Optional[str] = None + guest: bool + + +class LoginV2Rsp(ResponseBase): + data: Optional["Data"] = None + + class Data(BaseModel): + account_type: int + heartbeat: Optional[bool] = False + combo_id: Optional[str] = None + combo_token: Optional[str] = None + open_id: Optional[str] = None + data: Optional[str] = None + fatigue_remind: Optional[str] = None diff --git a/sdk_server/models/login/token_login_data.py b/sdk_server/models/login/token_login_data.py new file mode 100644 index 0000000..0983b5a --- /dev/null +++ b/sdk_server/models/login/token_login_data.py @@ -0,0 +1,6 @@ +from pydantic import BaseModel +from typing import Optional + +class TokenLoginReq(BaseModel): + uid: Optional[str] = None + token: Optional[str] = None diff --git a/sdkserver b/sdkserver new file mode 100644 index 0000000..4454213 --- /dev/null +++ b/sdkserver @@ -0,0 +1,4 @@ +from utils.config import Config +from sdk_server import run_http_server + +run_http_server(Config.SDKServer.IP,Config.SDKServer.Port) \ No newline at end of file diff --git a/utils/aes.py b/utils/aes.py new file mode 100644 index 0000000..5fed06e --- /dev/null +++ b/utils/aes.py @@ -0,0 +1,16 @@ +import base64 +from Crypto.Cipher import AES +from Crypto.Util.Padding import pad, unpad + + +def encrypt_ecb(key: str, data: str): + cipher = AES.new(bytes.fromhex(key.replace(" ", "")), AES.MODE_ECB) + encrypted = cipher.encrypt(pad(data.encode(), AES.block_size)) + return base64.b64encode(encrypted).decode() + + +def decrypt_ecb(key: str, data: str): + data = base64.b64decode(data) + cipher = AES.new(bytes.fromhex(key.replace(" ", "")), AES.MODE_ECB) + decrypted = cipher.decrypt(data) + return unpad(decrypted, AES.block_size).decode() diff --git a/utils/config.py b/utils/config.py new file mode 100644 index 0000000..a3bd6cb --- /dev/null +++ b/utils/config.py @@ -0,0 +1,42 @@ +from dataclasses import asdict, dataclass +import os +import json +from dacite import from_dict + + +@dataclass +class ServerConfig: + IP: str + Port: int + + +@dataclass +class ConfigData: + LogLevel: str + GameServer: ServerConfig + SDKServer: ServerConfig + RegionName: str + def write_default_config(): + config = ConfigData( + LogLevel="INFO", + GameServer=ServerConfig(IP="127.0.0.1", Port=23301), + SDKServer=ServerConfig(IP="127.0.0.1", Port=21000), + RegionName="NeonSR", + ) + with open("Config.json", "w") as f: + f.write(json.dumps(asdict(config), indent=2)) + + return config + + def load(): + if not os.path.exists("Config.json"): + return ConfigData.write_default_config() + + with open("Config.json", "r", encoding="utf-8") as f: + try: + return from_dict(ConfigData, json.load(f)) + except Exception: + return ConfigData.write_default_config() + + +Config : ConfigData = ConfigData.load() diff --git a/utils/crypto.py b/utils/crypto.py new file mode 100644 index 0000000..71babc2 --- /dev/null +++ b/utils/crypto.py @@ -0,0 +1,25 @@ +import os +import hashlib +import base64 +from datetime import datetime + +class Crypto: + @staticmethod + def create_session_key(account_uid: str) -> str: + random_bytes = os.urandom(64) + temp = f"{account_uid}.{datetime.now().timestamp()}.{random_bytes.hex()}" + try: + hash_bytes = hashlib.sha512(temp.encode('utf-8')).digest() + return base64.b64encode(hash_bytes).decode('utf-8') + except Exception as e: + hash_bytes = hashlib.sha512(temp.encode('utf-8')).digest() + return base64.b64encode(hash_bytes).decode('utf-8') + + +def generate_dispatch_token(uid) -> str: + dispatch_token = Crypto.create_session_key(uid) + return dispatch_token + +def generate_combo_token(uid) -> str: + dispatch_token = Crypto.create_session_key(uid) + return dispatch_token diff --git a/utils/logger.py b/utils/logger.py new file mode 100644 index 0000000..16c465d --- /dev/null +++ b/utils/logger.py @@ -0,0 +1,50 @@ +import sys +import os +from datetime import datetime +from loguru import logger +from utils.config import Config + +logger.remove() + +LevelList = ["ERROR", "WARNING", "INFO", "DEBUG"] +CodeColorDict = {"ERROR": "red", "WARNING": "yellow", "INFO": "green", "DEBUG": "blue"} + + +def custom_format(record): + color = CodeColorDict[record["level"].name] + return f"<{color}>{record['level'].name} : {record['message']}\n" + +logger.add(sys.stdout, format=custom_format, colorize=True, level=Config.LogLevel) + +def get_new_log_path(): + today = datetime.now().strftime("%Y-%m-%d") + log_dir = "logs" + os.makedirs(log_dir, exist_ok=True) + + count = 1 + while True: + filename = f"{today}-{count}.log" + filepath = os.path.join(log_dir, filename) + if not os.path.exists(filepath): + return filepath + count += 1 + + +log_file_path = get_new_log_path() +logger.add(log_file_path, level=Config.LogLevel, format="{time:YYYY-MM-DD HH:mm:ss} | {level} | {message}") + +def Log(msg, types): + if types in CodeColorDict and LevelList.index(types) <= LevelList.index(Config.LogLevel): + getattr(logger, types.lower())(msg) + +def Error(msg): + Log(msg, "ERROR") + +def Warn(msg): + Log(msg, "WARNING") + +def Info(msg): + Log(msg, "INFO") + +def Debug(msg): + Log(msg, "DEBUG") diff --git a/utils/time.py b/utils/time.py new file mode 100644 index 0000000..58366cc --- /dev/null +++ b/utils/time.py @@ -0,0 +1,4 @@ +from time import time + +def cur_timestamp_ms(): + return int((time() * 1000)) \ No newline at end of file diff --git a/version.json b/version.json new file mode 100644 index 0000000..877c070 --- /dev/null +++ b/version.json @@ -0,0 +1,104 @@ +{ + "OSBETAWin2.2.51": { + "asset_bundle_url": "https://autopatchos.starrails.com/asb/BetaLive/output_7037158_b67f5a6a68fb", + "ex_resource_url": "https://autopatchos.starrails.com/design_data/BetaLive/output_7033392_aaca9c1b456b", + "lua_url": "https://autopatchos.starrails.com/lua/BetaLive/output_7050564_f05a0f949b10", + "lua_version": "7050564" + }, + "CNBETAWin2.2.53": { + "asset_bundle_url": "https://autopatchcn.bhsr.com/asb/BetaLive/output_7128256_5f77b249238a", + "lua_url": "https://autopatchcn.bhsr.com/lua/BetaLive/output_7120090_469169697c23", + "ex_resource_url": "https://autopatchcn.bhsr.com/design_data/BetaLive/output_7134377_b1f36fb2d9b8", + "lua_version": "" + }, + "OSBETAWin2.2.53": { + "asset_bundle_url": "https://autopatchcn.bhsr.com/asb/BetaLive/output_7128256_5f77b249238a", + "ex_resource_url": "https://autopatchcn.bhsr.com/design_data/BetaLive/output_7134377_b1f36fb2d9b8", + "lua_url": "https://autopatchcn.bhsr.com/lua/BetaLive/output_7120090_469169697c23", + "lua_version": "7120090" + }, + "CNBETAWin2.3.51": { + "asset_bundle_url": "https://autopatchcn-ipv6.bhsr.com/asb/BetaLive/output_7327119_c52eec0f6a92", + "ex_resource_url": "https://autopatchcn-ipv6.bhsr.com/design_data/BetaLive/output_7344929_90885a8dc47c", + "lua_url": "https://autopatchcn-ipv6.bhsr.com/lua/BetaLive/output_7327274_d12d75929650", + "lua_version": "7327274" + }, + "OSBETAWin2.3.51": { + "asset_bundle_url": "https://autopatchcn-ipv6.bhsr.com/asb/BetaLive/output_7327119_c52eec0f6a92", + "ex_resource_url": "https://autopatchcn-ipv6.bhsr.com/design_data/BetaLive/output_7344929_90885a8dc47c", + "lua_url": "https://autopatchcn-ipv6.bhsr.com/lua/BetaLive/output_7327274_d12d75929650", + "lua_version": "7327274" + }, + "CNBETAWin2.3.53": { + "asset_bundle_url": "https://autopatchcn-ipv6.bhsr.com/asb/BetaLive/output_7435461_8cd43ab19921", + "ex_resource_url": "https://autopatchcn-ipv6.bhsr.com/design_data/BetaLive/output_7441503_fe09f8b8ab97", + "lua_url": "https://autopatchcn-ipv6.bhsr.com/lua/BetaLive/output_7435198_cb6c7842da93", + "lua_version": "7435198" + }, + "OSBETAWin2.3.53": { + "asset_bundle_url": "https://autopatchos.starrails.com/asb/BetaLive/output_7435461_8cd43ab19921", + "ex_resource_url": "https://autopatchos.starrails.com/design_data/BetaLive/output_7441503_fe09f8b8ab97", + "lua_url": "https://autopatchos.starrails.com/lua/BetaLive/output_7435198_cb6c7842da93", + "lua_version": "7435198" + }, + "CNBETAWin2.4.51": { + "asset_bundle_url": "https://autopatchcn-ipv6.bhsr.com/asb/BetaLive/output_7663997_cd086af3f307", + "ex_resource_url": "https://autopatchcn-ipv6.bhsr.com/design_data/BetaLive/output_7680597_a60760caba0f", + "lua_url": "https://autopatchcn-ipv6.bhsr.com/lua/BetaLive/output_7668875_0231727458ad", + "lua_version": "7668875" + }, + "CNBETAWin2.4.52": { + "asset_bundle_url": "https://autopatchcn.bhsr.com/asb/BetaLive/output_7705255_1e1ff2a185fd", + "ex_resource_url": "https://autopatchcn.bhsr.com/design_data/BetaLive/output_7707294_7609546fa884", + "lua_url": "https://autopatchcn.bhsr.com/lua/BetaLive/output_7705465_e8bd961bff37", + "lua_version": "0" + }, + "CNBETAWin2.5.51": { + "asset_bundle_url": "https://autopatchcn.bhsr.com/asb/BetaLive/output_7977788_8e5398808c48", + "ex_resource_url": "https://autopatchcn.bhsr.com/design_data/BetaLive/output_7986255_5ee49d99b9ab", + "lua_url": "https://autopatchcn.bhsr.com/lua/BetaLive/output_7980531_55efc4794b38", + "lua_version": "7980531" + }, + "CNBETAWin2.5.52": { + "asset_bundle_url": "https://autopatchcn.bhsr.com/asb/BetaLive/output_8023914_1c5d3bc509a7", + "ex_resource_url": "https://autopatchcn.bhsr.com/design_data/BetaLive/output_8023914_b27d1db5c7a4", + "lua_url": "https://autopatchcn.bhsr.com/lua/BetaLive/output_8023974_8a20ac590d04", + "lua_version": "8023974" + }, + "OSBETAWin2.5.52": { + "asset_bundle_url": "https://autopatchos.starrails.com/asb/BetaLive/output_8023914_1c5d3bc509a7", + "ex_resource_url": "https://autopatchos.starrails.com/design_data/BetaLive/output_8023914_b27d1db5c7a4", + "lua_url": "https://autopatchos.starrails.com/lua/BetaLive/output_8023974_8a20ac590d04", + "lua_version": "8023974" + }, + "OSBETAWin2.6.51": { + "asset_bundle_url": "https://autopatchos.starrails.com/asb/BetaLive/output_8255911_73424ed8f1d9", + "ex_resource_url": "https://autopatchos.starrails.com/design_data/BetaLive/output_8278172_2bef625c3daf", + "lua_url": "https://autopatchos.starrails.com/lua/BetaLive/output_8256066_d4950eb37f1e", + "lua_version": "8256066" + }, + "CNBETAWin2.6.51": { + "asset_bundle_url": "https://autopatchcn.bhsr.com/asb/BetaLive/output_8255911_73424ed8f1d9", + "ex_resource_url": "https://autopatchcn.bhsr.com/design_data/BetaLive/output_8278172_2bef625c3daf", + "lua_url": "https://autopatchcn.bhsr.com/lua/BetaLive/output_8256066_d4950eb37f1e", + "lua_version": "8256066" + }, + "CNBETAWin2.7.51": { + "asset_bundle_url": "https://autopatchcn.bhsr.com/asb/BetaLive/output_8741764_7b9b37c5472a", + "ex_resource_url": "https://autopatchcn.bhsr.com/design_data/BetaLive/output_8750523_aedf8b219ff5", + "lua_url": "https://autopatchcn.bhsr.com/lua/BetaLive/output_8731095_98d00821dbd1", + "lua_version": "8731095" + }, + "CNBETAWin2.7.53": { + "asset_bundle_url": "https://autopatchcn.bhsr.com/asb/BetaLive/output_8818564_f65307ddaa2b", + "ex_resource_url": "https://autopatchcn.bhsr.com/design_data/BetaLive/output_8950723_3ce1c3e895fa", + "lua_url": "https://autopatchcn.bhsr.com/lua/BetaLive/output_8831760_dcbf48d15383", + "lua_version": "8731095" + }, + "OSBETAWin2.7.53": { + "asset_bundle_url": "https://autopatchos.starrails.com/asb/BetaLive/output_8876487_71f1a5b21bd5", + "ex_resource_url": "https://autopatchos.starrails.com/design_data/BetaLive/output_8895614_cc6f3fdd930f", + "lua_url": "https://autopatchos.starrails.com/lua/BetaLive/output_8880072_11cae8e8e678", + "lua_version": "8731095" + } +}