bemaniutils/bemani/backend/popn/tunestreet.py

# 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.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.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")