# vim: set fileencoding=utf-8 from typing import Dict, Any from typing_extensions import Final from bemani.backend.popn.base import PopnMusicBase from bemani.backend.popn.stubs import PopnMusicSengokuRetsuden from bemani.backend.base import Status from bemani.common import Profile, VersionConstants from bemani.data import Score, UserID from bemani.protocol import Node class PopnMusicTuneStreet(PopnMusicBase): name: str = "Pop'n Music TUNE STREET" version: int = VersionConstants.POPN_MUSIC_TUNE_STREET # Play modes, as reported by profile save from the game GAME_PLAY_MODE_CHALLENGE: Final[int] = 3 GAME_PLAY_MODE_CHO_CHALLENGE: Final[int] = 4 GAME_PLAY_MODE_TOWN_CHO_CHALLENGE: Final[int] = 15 # Play flags, as saved into/loaded from the DB GAME_PLAY_FLAG_FAILED: Final[int] = 0 GAME_PLAY_FLAG_CLEARED: Final[int] = 1 GAME_PLAY_FLAG_FULL_COMBO: Final[int] = 2 GAME_PLAY_FLAG_PERFECT_COMBO: Final[int] = 3 # Chart type, as reported by profile save from the game GAME_CHART_TYPE_NORMAL: Final[int] = 0 GAME_CHART_TYPE_HYPER: Final[int] = 1 GAME_CHART_TYPE_5_BUTTON: Final[int] = 2 GAME_CHART_TYPE_EX: Final[int] = 3 GAME_CHART_TYPE_BATTLE_NORMAL: Final[int] = 4 GAME_CHART_TYPE_BATTLE_HYPER: Final[int] = 5 GAME_CHART_TYPE_ENJOY_5_BUTTON: Final[int] = 6 GAME_CHART_TYPE_ENJOY_9_BUTTON: Final[int] = 7 # Extra chart types supported by Pop'n 19 CHART_TYPE_OLD_NORMAL: Final[int] = 4 CHART_TYPE_OLD_HYPER: Final[int] = 5 CHART_TYPE_OLD_EX: Final[int] = 6 CHART_TYPE_ENJOY_5_BUTTON: Final[int] = 7 CHART_TYPE_ENJOY_9_BUTTON: Final[int] = 8 CHART_TYPE_5_BUTTON: Final[int] = 9 # Chart type, as packed into a hiscore binary GAME_CHART_TYPE_5_BUTTON_POSITION: Final[int] = 0 GAME_CHART_TYPE_NORMAL_POSITION: Final[int] = 1 GAME_CHART_TYPE_HYPER_POSITION: Final[int] = 2 GAME_CHART_TYPE_EX_POSITION: Final[int] = 3 GAME_CHART_TYPE_CHO_NORMAL_POSITION: Final[int] = 4 GAME_CHART_TYPE_CHO_HYPER_POSITION: Final[int] = 5 GAME_CHART_TYPE_CHO_EX_POSITION: Final[int] = 6 # Highest song ID we can represent GAME_MAX_MUSIC_ID: Final[int] = 1045 def previous_version(self) -> PopnMusicBase: return PopnMusicSengokuRetsuden(self.data, self.config, self.model) @classmethod def get_settings(cls) -> Dict[str, Any]: """ Return all of our front-end modifiably settings. """ return { "ints": [ { "name": "Game Phase", "tip": "Game unlock phase for all players.", "category": "game_config", "setting": "game_phase", "values": { 0: "NO PHASE", 1: "SECRET DATA RELEASE", 2: "MAX: ALL DATA RELEASE", }, }, { "name": "Town Mode Phase", "tip": "Town mode phase for all players.", "category": "game_config", "setting": "town_phase", "values": { 0: "town mode disabled", 1: "town phase 1", 2: "town phase 2", 3: "Pop'n Naan Festival", # 4 seems to be a continuation of town phase 2. Intentionally leaving it out. 5: "town phase 3", 6: "town phase 4", 7: "Miracle 4 + 1", # 8 seems to be a continuation of town phase 4. Intentionally leaving it out. 9: "town phase MAX", 10: "Find your daughter!", # 11 is a continuation of phase MAX after find your daughter, with Tanabata # bamboo grass added as well. 11: "town phase MAX+1", 12: "Peruri-san visits", # 13 is a continuation of phase MAX+1 after peruri-san visits, with Watermelon # pattern tank added as well. 13: "town phase MAX+2", 14: "Find Deuil!", # 15 is a continuation of phase MAX+2 after find deuil, with Tsukimi dumplings # added as well. 15: "town phase MAX+3", 16: "Landmark stamp rally", # 17 is a continuation of MAX+3 after landmark stamp rally ends, but offering # no additional stuff. }, }, ], "bools": [ { "name": "Force Song Unlock", "tip": "Force unlock all songs.", "category": "game_config", "setting": "force_unlock_songs", }, { "name": "Force Customization Unlock", "tip": "Force unlock all theme and menu customizations.", "category": "game_config", "setting": "force_unlock_customizations", }, ], } def __format_flags_for_score(self, score: Score) -> int: # Format song flags (cleared/not, combo flags) playedflag = { self.CHART_TYPE_5_BUTTON: 0x2000, self.CHART_TYPE_OLD_NORMAL: 0x0800, self.CHART_TYPE_OLD_HYPER: 0x1000, self.CHART_TYPE_OLD_EX: 0x4000, self.CHART_TYPE_NORMAL: 0x0800, self.CHART_TYPE_HYPER: 0x1000, self.CHART_TYPE_EX: 0x4000, # We don't have a played flag for these, only cleared/no play self.CHART_TYPE_ENJOY_5_BUTTON: 0, self.CHART_TYPE_ENJOY_9_BUTTON: 0, }[score.chart] # Shift value for cleared/failed/combo indicators shift = { self.CHART_TYPE_5_BUTTON: 4, self.CHART_TYPE_OLD_NORMAL: 0, self.CHART_TYPE_OLD_HYPER: 2, self.CHART_TYPE_OLD_EX: 6, self.CHART_TYPE_NORMAL: 0, self.CHART_TYPE_HYPER: 2, self.CHART_TYPE_EX: 6, self.CHART_TYPE_ENJOY_5_BUTTON: 9, self.CHART_TYPE_ENJOY_9_BUTTON: 8, }[score.chart] flags = { self.PLAY_MEDAL_CIRCLE_FAILED: self.GAME_PLAY_FLAG_FAILED, self.PLAY_MEDAL_DIAMOND_FAILED: self.GAME_PLAY_FLAG_FAILED, self.PLAY_MEDAL_STAR_FAILED: self.GAME_PLAY_FLAG_FAILED, self.PLAY_MEDAL_EASY_CLEAR: self.GAME_PLAY_FLAG_CLEARED, self.PLAY_MEDAL_CIRCLE_CLEARED: self.GAME_PLAY_FLAG_CLEARED, self.PLAY_MEDAL_DIAMOND_CLEARED: self.GAME_PLAY_FLAG_CLEARED, self.PLAY_MEDAL_STAR_CLEARED: self.GAME_PLAY_FLAG_CLEARED, self.PLAY_MEDAL_CIRCLE_FULL_COMBO: self.GAME_PLAY_FLAG_FULL_COMBO, self.PLAY_MEDAL_DIAMOND_FULL_COMBO: self.GAME_PLAY_FLAG_FULL_COMBO, self.PLAY_MEDAL_STAR_FULL_COMBO: self.GAME_PLAY_FLAG_FULL_COMBO, self.PLAY_MEDAL_PERFECT: self.GAME_PLAY_FLAG_PERFECT_COMBO, }[score.data.get_int("medal")] return (flags << shift) | playedflag def format_profile(self, userid: UserID, profile: Profile) -> Node: root = Node.void("playerdata") # Format profile binary_profile = [0] * 2198 # Copy name. We intentionally leave location 12 alone as it is # the null termination for the name if it happens to be 12 # characters (6 shift-jis kana). name_binary = profile.get_str("name", "なし").encode("shift-jis")[0:12] for name_pos, byte in enumerate(name_binary): binary_profile[name_pos] = byte # Copy game mode. Modes sent to the game are as follows. # 0 - Enjoy mode. # 1 - Challenge mode. # 2 - Battle mode. # 3 - Net ranking mode (enabled by setting netvs_phase in game.get). # 4 - Cho challenge mode. # 5 - Town mode (enabled by event_phase in game.get). binary_profile[13] = { 0: 0, 1: 0, 2: 1, 3: 1, 4: 4, 5: 2, 13: 5, 14: 5, 15: 5, }[profile.get_int("play_mode")] # Copy miscelaneous values binary_profile[15] = profile.get_int("last_play_flag") & 0xFF binary_profile[16] = profile.get_int("medal_and_friend") & 0xFF binary_profile[37] = profile.get_int("read_news") & 0xFF binary_profile[38] = profile.get_int("skin_tex_note") & 0xFF binary_profile[39] = profile.get_int("skin_tex_cmn") & 0xFF binary_profile[40] = profile.get_int("skin_sd_bgm") & 0xFF binary_profile[41] = profile.get_int("skin_sd_se") & 0xFF binary_profile[44] = profile.get_int("option") & 0xFF binary_profile[45] = (profile.get_int("option") >> 8) & 0xFF binary_profile[46] = (profile.get_int("option") >> 16) & 0xFF binary_profile[47] = (profile.get_int("option") >> 24) & 0xFF binary_profile[48] = profile.get_int("jubeat_collabo") & 0xFF binary_profile[49] = (profile.get_int("jubeat_collabo") >> 8) & 0xFF # 52-56 and 56-60 make up two 32 bit colors found in color_3p_flag. binary_profile[60] = profile.get_int("chara", -1) & 0xFF binary_profile[61] = (profile.get_int("chara", -1) >> 8) & 0xFF binary_profile[62] = profile.get_int("music") & 0xFF binary_profile[63] = (profile.get_int("music") >> 8) & 0xFF binary_profile[64] = profile.get_int("sheet") & 0xFF binary_profile[65] = profile.get_int("category") & 0xFF binary_profile[66] = profile.get_int("norma_point") & 0xFF binary_profile[67] = (profile.get_int("norma_point") >> 8) & 0xFF # Format Scores hiscore_array = [0] * int((((self.GAME_MAX_MUSIC_ID * 7) * 17) + 7) / 8) scores = self.data.remote.music.get_scores( self.game, self.music_version, userid ) for score in scores: if score.id > self.GAME_MAX_MUSIC_ID: continue # Skip any scores for chart types we don't support if score.chart in [ self.CHART_TYPE_EASY, ]: continue if score.data.get_int("medal") == self.PLAY_MEDAL_NO_PLAY: continue flags = self.__format_flags_for_score(score) flags_index = score.id * 2 binary_profile[108 + flags_index] = binary_profile[108 + flags_index] | ( flags & 0xFF ) binary_profile[109 + flags_index] = binary_profile[109 + flags_index] | ( (flags >> 8) & 0xFF ) if score.chart in [ self.CHART_TYPE_ENJOY_5_BUTTON, self.CHART_TYPE_ENJOY_9_BUTTON, ]: # We don't return enjoy scores, just the flags that we played them continue # Format actual score, according to DB chart position hiscore_index = (score.id * 7) + { self.CHART_TYPE_5_BUTTON: self.GAME_CHART_TYPE_5_BUTTON_POSITION, self.CHART_TYPE_OLD_NORMAL: self.GAME_CHART_TYPE_NORMAL_POSITION, self.CHART_TYPE_OLD_HYPER: self.GAME_CHART_TYPE_HYPER_POSITION, self.CHART_TYPE_OLD_EX: self.GAME_CHART_TYPE_EX_POSITION, self.CHART_TYPE_NORMAL: self.GAME_CHART_TYPE_CHO_NORMAL_POSITION, self.CHART_TYPE_HYPER: self.GAME_CHART_TYPE_CHO_HYPER_POSITION, self.CHART_TYPE_EX: self.GAME_CHART_TYPE_CHO_EX_POSITION, }[score.chart] hiscore_byte_pos = int((hiscore_index * 17) / 8) hiscore_bit_pos = int((hiscore_index * 17) % 8) hiscore_value = score.points << hiscore_bit_pos hiscore_array[hiscore_byte_pos] = hiscore_array[hiscore_byte_pos] | ( hiscore_value & 0xFF ) hiscore_array[hiscore_byte_pos + 1] = hiscore_array[ hiscore_byte_pos + 1 ] | ((hiscore_value >> 8) & 0xFF) hiscore_array[hiscore_byte_pos + 2] = hiscore_array[ hiscore_byte_pos + 2 ] | ((hiscore_value >> 16) & 0xFF) # Format most played most_played = [ x[0] for x in self.data.local.music.get_most_played( self.game, self.music_version, userid, 20 ) ] while len(most_played) < 20: most_played.append(-1) profile_pos = 68 for musicid in most_played: binary_profile[profile_pos] = musicid & 0xFF binary_profile[profile_pos + 1] = (musicid >> 8) & 0xFF profile_pos = profile_pos + 2 # Town purchases, including BGM/announcer changes and such. # The town customization area will show up if the player owns # one or more customization in any of the following four # purchase locations. These are all purchased in town mode. # - 4-7 are song unlock flags. # - 8 appears to be purchased pop-kuns. # - 9 appears to be purchased themes. # - 10 appears to be purchased BGMs. # - 11 appears to be purchased sound effects. binary_town = [0] * 141 town = profile.get_dict("town") # Last play flag, so the selection for 5/9/9+cool sticks. binary_town[140] = town.get_int("play_type") # Fill in basic town points, tracked here and returned in basic profile for some reason. binary_town[0] = town.get_int("points") & 0xFF binary_town[1] = (town.get_int("points") >> 8) & 0xFF binary_town[2] = (town.get_int("points") >> 16) & 0xFF binary_town[3] = (town.get_int("points") >> 24) & 0xFF # Fill in purchase flags (this is for stuff like BGMs, SEs, Pop-kun customizations, etc). bought_flg = town.get_int_array("bought_flg", 3) game_config = self.get_game_config() force_unlock_songs = game_config.get_bool("force_unlock_songs") force_unlock_customizations = game_config.get_bool( "force_unlock_customizations" ) if force_unlock_songs: bought_flg[0] = 0xFFFFFFFF if force_unlock_customizations: bought_flg[1] = 0xFFFFFFFF for flg, off in enumerate([4, 8, 12]): binary_town[off + 0] = bought_flg[flg] & 0xFF binary_town[off + 1] = (bought_flg[flg] >> 8) & 0xFF binary_town[off + 2] = (bought_flg[flg] >> 16) & 0xFF binary_town[off + 3] = (bought_flg[flg] >> 24) & 0xFF # Fill in build flags (presumably for what parcels of land have been bought and built on). build_flg = town.get_int_array("build_flg", 8) for flg, off in enumerate([16, 20, 24, 28, 32, 36, 40, 44]): binary_town[off + 0] = build_flg[flg] & 0xFF binary_town[off + 1] = (build_flg[flg] >> 8) & 0xFF binary_town[off + 2] = (build_flg[flg] >> 16) & 0xFF binary_town[off + 3] = (build_flg[flg] >> 24) & 0xFF # Fill in character flags (presumably for character location, orientation, stats, etc). chara_flg = town.get_int_array("chara_flg", 19) for flg, off in enumerate( [ 48, 52, 56, 60, 64, 68, 72, 76, 80, 84, 88, 92, 96, 100, 104, 108, 112, 116, 120, ] ): binary_town[off + 0] = chara_flg[flg] & 0xFF binary_town[off + 1] = (chara_flg[flg] >> 8) & 0xFF binary_town[off + 2] = (chara_flg[flg] >> 16) & 0xFF binary_town[off + 3] = (chara_flg[flg] >> 24) & 0xFF # Fill in miscellaneous event flags. event_flg = town.get_int_array("event_flg", 4) for flg, off in enumerate([124, 128, 132, 136]): binary_town[off + 0] = event_flg[flg] & 0xFF binary_town[off + 1] = (event_flg[flg] >> 8) & 0xFF binary_town[off + 2] = (event_flg[flg] >> 16) & 0xFF binary_town[off + 3] = (event_flg[flg] >> 24) & 0xFF # Construct final profile root.add_child(Node.binary("b", bytes(binary_profile))) root.add_child(Node.binary("hiscore", bytes(hiscore_array))) root.add_child(Node.binary("town", bytes(binary_town))) return root def unformat_profile( self, userid: UserID, request: Node, oldprofile: Profile ) -> Profile: newprofile = oldprofile.clone() # Extract the playmode, important for scores later playmode = int(request.attribute("play_mode")) newprofile.replace_int("play_mode", playmode) # Extract profile options newprofile.replace_int("chara", int(request.attribute("chara_num"))) if "option" in request.attributes: newprofile.replace_int("option", int(request.attribute("option"))) if "last_play_flag" in request.attributes: newprofile.replace_int( "last_play_flag", int(request.attribute("last_play_flag")) ) if "medal_and_friend" in request.attributes: newprofile.replace_int( "medal_and_friend", int(request.attribute("medal_and_friend")) ) if "music_num" in request.attributes: newprofile.replace_int("music", int(request.attribute("music_num"))) if "sheet_num" in request.attributes: newprofile.replace_int("sheet", int(request.attribute("sheet_num"))) if "category_num" in request.attributes: newprofile.replace_int("category", int(request.attribute("category_num"))) if "read_news_no_max" in request.attributes: newprofile.replace_int( "read_news", int(request.attribute("read_news_no_max")) ) if "jubeat_collabo" in request.attributes: newprofile.replace_int( "jubeat_collabo", int(request.attribute("jubeat_collabo")) ) if "norma_point" in request.attributes: newprofile.replace_int("norma_point", int(request.attribute("norma_point"))) if "skin_tex_note" in request.attributes: newprofile.replace_int( "skin_tex_note", int(request.attribute("skin_tex_note")) ) if "skin_tex_cmn" in request.attributes: newprofile.replace_int( "skin_tex_cmn", int(request.attribute("skin_tex_cmn")) ) if "skin_sd_bgm" in request.attributes: newprofile.replace_int("skin_sd_bgm", int(request.attribute("skin_sd_bgm"))) if "skin_sd_se" in request.attributes: newprofile.replace_int("skin_sd_se", int(request.attribute("skin_sd_se"))) # Keep track of play statistics self.update_play_statistics(userid) # Extract scores for node in request.children: if node.name == "music": songid = int(node.attribute("music_num")) chart = int(node.attribute("sheet_num")) points = int(node.attribute("score")) data = int(node.attribute("data")) # We never save battle scores if chart in [ self.GAME_CHART_TYPE_BATTLE_NORMAL, self.GAME_CHART_TYPE_BATTLE_HYPER, ]: continue # Arrange order to be compatible with future mixes if playmode in { self.GAME_PLAY_MODE_CHO_CHALLENGE, self.GAME_PLAY_MODE_TOWN_CHO_CHALLENGE, }: if chart in [ self.GAME_CHART_TYPE_5_BUTTON, self.GAME_CHART_TYPE_ENJOY_5_BUTTON, self.GAME_CHART_TYPE_ENJOY_9_BUTTON, ]: # We don't save 5 button for cho scores, or enjoy modes continue chart = { self.GAME_CHART_TYPE_NORMAL: self.CHART_TYPE_NORMAL, self.GAME_CHART_TYPE_HYPER: self.CHART_TYPE_HYPER, self.GAME_CHART_TYPE_EX: self.CHART_TYPE_EX, }[chart] else: chart = { self.GAME_CHART_TYPE_NORMAL: self.CHART_TYPE_OLD_NORMAL, self.GAME_CHART_TYPE_HYPER: self.CHART_TYPE_OLD_HYPER, self.GAME_CHART_TYPE_5_BUTTON: self.CHART_TYPE_5_BUTTON, self.GAME_CHART_TYPE_EX: self.CHART_TYPE_OLD_EX, self.GAME_CHART_TYPE_ENJOY_5_BUTTON: self.CHART_TYPE_ENJOY_5_BUTTON, self.GAME_CHART_TYPE_ENJOY_9_BUTTON: self.CHART_TYPE_ENJOY_9_BUTTON, }[chart] # Extract play flags shift = { self.CHART_TYPE_5_BUTTON: 4, self.CHART_TYPE_OLD_NORMAL: 0, self.CHART_TYPE_OLD_HYPER: 2, self.CHART_TYPE_OLD_EX: 6, self.CHART_TYPE_NORMAL: 0, self.CHART_TYPE_HYPER: 2, self.CHART_TYPE_EX: 6, self.CHART_TYPE_ENJOY_5_BUTTON: 9, self.CHART_TYPE_ENJOY_9_BUTTON: 8, }[chart] if chart in [ self.CHART_TYPE_ENJOY_5_BUTTON, self.CHART_TYPE_ENJOY_9_BUTTON, ]: # We only store cleared or not played for enjoy mode mask = 0x1 else: # We store all data for regular charts mask = 0x3 # Grab flags, map to medals in DB. Choose lowest one for each so # a newer pop'n can still improve scores and medals. flags = (data >> shift) & mask medal = { self.GAME_PLAY_FLAG_FAILED: self.PLAY_MEDAL_CIRCLE_FAILED, self.GAME_PLAY_FLAG_CLEARED: self.PLAY_MEDAL_CIRCLE_CLEARED, self.GAME_PLAY_FLAG_FULL_COMBO: self.PLAY_MEDAL_CIRCLE_FULL_COMBO, self.GAME_PLAY_FLAG_PERFECT_COMBO: self.PLAY_MEDAL_PERFECT, }[flags] self.update_score(userid, songid, chart, points, medal) # Update town mode data. town = newprofile.get_dict("town") # Basic stuff that's in the base node for no reason? if "tp" in request.attributes: town.replace_int("points", int(request.attribute("tp"))) # Stuff that is in the town node townnode = request.child("town") if townnode is not None: if "play_type" in townnode.attributes: town.replace_int("play_type", int(townnode.attribute("play_type"))) if "base" in townnode.attributes: town.replace_int_array( "base", 4, [int(x) for x in townnode.attribute("base").split(",")] ) if "bought_flg" in townnode.attributes: bought_array = [ int(x) for x in townnode.attribute("bought_flg").split(",") ] if len(bought_array) == 3: game_config = self.get_game_config() force_unlock_songs = game_config.get_bool("force_unlock_songs") force_unlock_customizations = game_config.get_bool( "force_unlock_customizations" ) old_bought_array = town.get_int_array("bought_flg", 3) if force_unlock_songs: # Don't save force unlocked flags, it'll clobber the profile. bought_array[0] = old_bought_array[0] if force_unlock_customizations: # Don't save force unlocked flags, it'll clobber the profile. bought_array[1] = old_bought_array[1] town.replace_int_array("bought_flg", 3, bought_array) if "build_flg" in townnode.attributes: town.replace_int_array( "build_flg", 8, [int(x) for x in townnode.attribute("build_flg").split(",")], ) if "chara_flg" in townnode.attributes: town.replace_int_array( "chara_flg", 19, [int(x) for x in townnode.attribute("chara_flg").split(",")], ) if "event_flg" in townnode.attributes: town.replace_int_array( "event_flg", 4, [int(x) for x in townnode.attribute("event_flg").split(",")], ) for bid in range(8): if f"building_{bid}" in townnode.attributes: town.replace_int_array( f"building_{bid}", 8, [ int(x) for x in townnode.attribute(f"building_{bid}").split(",") ], ) newprofile.replace_dict("town", town) return newprofile def handle_game_get_request(self, request: Node) -> Node: game_config = self.get_game_config() game_phase = game_config.get_int("game_phase") town_phase = game_config.get_int("town_phase") root = Node.void("game") root.set_attribute( "game_phase", str(game_phase) ) # Phase unlocks, for song availability. root.set_attribute("boss_battle_point", "1") root.set_attribute("boss_diff", "100,100,100,100,100,100,100,100,100,100") root.set_attribute("card_phase", "3") root.set_attribute( "event_phase", str(town_phase) ) # Town mode, for the main event. root.set_attribute("gfdm_phase", "2") root.set_attribute("ir_phase", "14") root.set_attribute("jubeat_phase", "2") root.set_attribute("local_matching_enable", "1") root.set_attribute("matching_sec", "120") root.set_attribute( "netvs_phase", "0" ) # Net taisen mode phase, maximum 18 (no lobby support). return root def handle_game_active_request(self, request: Node) -> Node: # Update the name of this cab for admin purposes self.update_machine_name(request.attribute("shop_name")) return Node.void("game") def handle_playerdata_expire_request(self, request: Node) -> Node: return Node.void("playerdata") def handle_playerdata_logout_request(self, request: Node) -> Node: return Node.void("playerdata") def handle_playerdata_get_request(self, request: Node) -> Node: modelstring = request.attribute("model") refid = request.attribute("ref_id") root = self.get_profile_by_refid( refid, self.NEW_PROFILE_ONLY if modelstring is None else self.OLD_PROFILE_ONLY, ) if root is None: root = Node.void("playerdata") root.set_attribute("status", str(Status.NO_PROFILE)) return root def handle_playerdata_town_request(self, request: Node) -> Node: refid = request.attribute("ref_id") root = Node.void("playerdata") userid = self.data.remote.user.from_refid(self.game, self.version, refid) if userid is None: return root profile = self.get_profile(userid) if profile is None: return root town = profile.get_dict("town") residence = Node.void("residence") root.add_child(residence) residence.set_attribute("id", str(town.get_int("residence"))) # It appears there can be up to 9 map nodes, not sure why. I'm only returning the # first one. Perhaps if there's multiple towns, the residence ID lets you choose # between them? Maybe it has to do with friends towns? mapdata = [0] * 180 # Map over progress for base and buildings. Positions 173-176 are for base flags. base = town.get_int_array("base", 4) for i in range(4): mapdata[173 + i] = base[i] # Positions 42-105 are for building flags. for bid, start in enumerate([42, 50, 58, 66, 74, 82, 90, 98]): building = town.get_int_array(f"building_{bid}", 8) for i in range(8): mapdata[start + i] = building[i] mapnode = Node.binary("map", bytes(mapdata)) root.add_child(mapnode) mapnode.set_attribute("residence", "0") return root def handle_playerdata_new_request(self, request: Node) -> Node: refid = request.attribute("ref_id") name = request.attribute("name") root = self.new_profile_by_refid(refid, name) if root is None: root = Node.void("playerdata") root.set_attribute("status", str(Status.NO_PROFILE)) return root def handle_playerdata_set_request(self, request: Node) -> Node: refid = request.attribute("ref_id") root = Node.void("playerdata") if refid is None: return root userid = self.data.remote.user.from_refid(self.game, self.version, refid) if userid is None: return root oldprofile = self.get_profile(userid) or Profile( self.game, self.version, refid, 0 ) newprofile = self.unformat_profile(userid, request, oldprofile) if newprofile is not None: self.put_profile(userid, newprofile) return root def handle_lobby_requests(self, request: Node) -> Node: # Stub out the entire lobby service return Node.void("lobby")