bemaniutils/bemani/backend/reflec/groovin.py

from typing import Optional, Dict, Any, List, Tuple
from typing_extensions import Final

from bemani.backend.reflec.base import ReflecBeatBase
from bemani.backend.reflec.colette import ReflecBeatColette

from bemani.common import Profile, ValidatedDict, VersionConstants, ID, Time
from bemani.data import Achievement, Attempt, Score, UserID
from bemani.protocol import Node


class ReflecBeatGroovin(ReflecBeatBase):
    name: str = "REFLEC BEAT groovin'!!"
    version: int = VersionConstants.REFLEC_BEAT_GROOVIN

    # Clear types according to the game
    GAME_CLEAR_TYPE_NO_PLAY: Final[int] = 0
    GAME_CLEAR_TYPE_EARLY_FAILED: Final[int] = 1
    GAME_CLEAR_TYPE_FAILED: Final[int] = 2
    GAME_CLEAR_TYPE_CLEARED: Final[int] = 9
    GAME_CLEAR_TYPE_HARD_CLEARED: Final[int] = 10
    GAME_CLEAR_TYPE_S_HARD_CLEARED: Final[int] = 11

    # Combo types according to the game (actually a bitmask, where bit 0 is
    # full combo status, and bit 2 is just reflec status). But we don't support
    # saving just reflec without full combo, so we downgrade it.
    GAME_COMBO_TYPE_NONE: Final[int] = 0
    GAME_COMBO_TYPE_ALL_JUST: Final[int] = 2
    GAME_COMBO_TYPE_FULL_COMBO: Final[int] = 1
    GAME_COMBO_TYPE_FULL_COMBO_ALL_JUST: Final[int] = 3

    def previous_version(self) -> Optional[ReflecBeatBase]:
        return ReflecBeatColette(self.data, self.config, self.model)

    @classmethod
    def get_settings(cls) -> Dict[str, Any]:
        """
        Return all of our front-end modifiably settings.
        """
        return {
            "bools": [
                {
                    "name": "Force Song Unlock",
                    "tip": "Force unlock all songs.",
                    "category": "game_config",
                    "setting": "force_unlock_songs",
                },
            ],
            "ints": [],
        }

    def __db_to_game_clear_type(self, db_status: int) -> int:
        return {
            self.CLEAR_TYPE_NO_PLAY: self.GAME_CLEAR_TYPE_NO_PLAY,
            self.CLEAR_TYPE_FAILED: self.GAME_CLEAR_TYPE_FAILED,
            self.CLEAR_TYPE_CLEARED: self.GAME_CLEAR_TYPE_CLEARED,
            self.CLEAR_TYPE_HARD_CLEARED: self.GAME_CLEAR_TYPE_HARD_CLEARED,
            self.CLEAR_TYPE_S_HARD_CLEARED: self.GAME_CLEAR_TYPE_S_HARD_CLEARED,
        }[db_status]

    def __game_to_db_clear_type(self, status: int) -> int:
        return {
            self.GAME_CLEAR_TYPE_NO_PLAY: self.CLEAR_TYPE_NO_PLAY,
            self.GAME_CLEAR_TYPE_EARLY_FAILED: self.CLEAR_TYPE_FAILED,
            self.GAME_CLEAR_TYPE_FAILED: self.CLEAR_TYPE_FAILED,
            self.GAME_CLEAR_TYPE_CLEARED: self.CLEAR_TYPE_CLEARED,
            self.GAME_CLEAR_TYPE_HARD_CLEARED: self.CLEAR_TYPE_HARD_CLEARED,
            self.GAME_CLEAR_TYPE_S_HARD_CLEARED: self.CLEAR_TYPE_S_HARD_CLEARED,
        }[status]

    def __db_to_game_combo_type(self, db_combo: int) -> int:
        return {
            self.COMBO_TYPE_NONE: self.GAME_COMBO_TYPE_NONE,
            self.COMBO_TYPE_ALMOST_COMBO: self.GAME_COMBO_TYPE_NONE,
            self.COMBO_TYPE_FULL_COMBO: self.GAME_COMBO_TYPE_FULL_COMBO,
            self.COMBO_TYPE_FULL_COMBO_ALL_JUST: self.GAME_COMBO_TYPE_FULL_COMBO_ALL_JUST,
        }[db_combo]

    def __game_to_db_combo_type(self, game_combo: int, miss_count: int) -> int:
        if game_combo in [
            self.GAME_COMBO_TYPE_NONE,
            self.GAME_COMBO_TYPE_ALL_JUST,
        ]:
            if miss_count >= 0 and miss_count <= 2:
                return self.COMBO_TYPE_ALMOST_COMBO
            else:
                return self.COMBO_TYPE_NONE
        if game_combo == self.GAME_COMBO_TYPE_FULL_COMBO:
            return self.COMBO_TYPE_FULL_COMBO
        if game_combo == self.GAME_COMBO_TYPE_FULL_COMBO_ALL_JUST:
            return self.COMBO_TYPE_FULL_COMBO_ALL_JUST
        raise Exception(f"Invalid game_combo value {game_combo}")

    def handle_pcb_rb4error_request(self, request: Node) -> Node:
        return Node.void("pcb")

    def handle_pcb_rb4uptime_update_request(self, request: Node) -> Node:
        return Node.void("pcb")

    def handle_pcb_rb4boot_request(self, request: Node) -> Node:
        shop_id = ID.parse_machine_id(request.child_value("lid"))
        machine = self.get_machine_by_id(shop_id)
        if machine is not None:
            machine_name = machine.name
            close = machine.data.get_bool("close")
            hour = machine.data.get_int("hour")
            minute = machine.data.get_int("minute")
        else:
            machine_name = ""
            close = False
            hour = 0
            minute = 0

        root = Node.void("pcb")
        sinfo = Node.void("sinfo")
        root.add_child(sinfo)
        sinfo.add_child(Node.string("nm", machine_name))
        sinfo.add_child(Node.bool("cl_enbl", close))
        sinfo.add_child(Node.u8("cl_h", hour))
        sinfo.add_child(Node.u8("cl_m", minute))
        sinfo.add_child(Node.bool("shop_flag", True))
        return root

    def handle_lobby_rb4entry_request(self, request: Node) -> Node:
        root = Node.void("lobby")
        root.add_child(Node.s32("interval", 120))
        root.add_child(Node.s32("interval_p", 120))

        # Create a lobby entry for this user
        extid = request.child_value("e/uid")
        userid = self.data.remote.user.from_extid(self.game, self.version, extid)
        if userid is not None:
            profile = self.get_profile(userid)
            info = self.data.local.lobby.get_play_session_info(
                self.game, self.version, userid
            )
            if profile is None or info is None:
                return root

            self.data.local.lobby.put_lobby(
                self.game,
                self.version,
                userid,
                {
                    "mid": request.child_value("e/mid"),
                    "ng": request.child_value("e/ng"),
                    "mopt": request.child_value("e/mopt"),
                    "lid": request.child_value("e/lid"),
                    "sn": request.child_value("e/sn"),
                    "pref": request.child_value("e/pref"),
                    "stg": request.child_value("e/stg"),
                    "pside": request.child_value("e/pside"),
                    "eatime": request.child_value("e/eatime"),
                    "ga": request.child_value("e/ga"),
                    "gp": request.child_value("e/gp"),
                    "la": request.child_value("e/la"),
                    "ver": request.child_value("e/ver"),
                    "tension": request.child_value("e/tension"),
                },
            )
            lobby = self.data.local.lobby.get_lobby(
                self.game,
                self.version,
                userid,
            )
            root.add_child(Node.s32("eid", lobby.get_int("id")))
            e = Node.void("e")
            root.add_child(e)
            e.add_child(Node.s32("eid", lobby.get_int("id")))
            e.add_child(Node.u16("mid", lobby.get_int("mid")))
            e.add_child(Node.u8("ng", lobby.get_int("ng")))
            e.add_child(Node.s32("uid", profile.extid))
            e.add_child(Node.s32("uattr", profile.get_int("uattr")))
            e.add_child(Node.string("pn", profile.get_str("name")))
            e.add_child(Node.s32("plyid", info.get_int("id")))
            e.add_child(Node.s16("mg", profile.get_int("mg")))
            e.add_child(Node.s32("mopt", lobby.get_int("mopt")))
            e.add_child(Node.string("lid", lobby.get_str("lid")))
            e.add_child(Node.string("sn", lobby.get_str("sn")))
            e.add_child(Node.u8("pref", lobby.get_int("pref")))
            e.add_child(Node.s8("stg", lobby.get_int("stg")))
            e.add_child(Node.s8("pside", lobby.get_int("pside")))
            e.add_child(Node.s16("eatime", lobby.get_int("eatime")))
            e.add_child(Node.u8_array("ga", lobby.get_int_array("ga", 4)))
            e.add_child(Node.u16("gp", lobby.get_int("gp")))
            e.add_child(Node.u8_array("la", lobby.get_int_array("la", 4)))
            e.add_child(Node.u8("ver", lobby.get_int("ver")))
            e.add_child(Node.s8("tension", lobby.get_int("tension")))

        return root

    def handle_lobby_rb4read_request(self, request: Node) -> Node:
        root = Node.void("lobby")
        root.add_child(Node.s32("interval", 120))
        root.add_child(Node.s32("interval_p", 120))

        # Look up all lobbies matching the criteria specified
        ver = request.child_value("var")
        mg = request.child_value("m_grade")  # noqa: F841
        extid = request.child_value("uid")
        limit = request.child_value("max")
        userid = self.data.remote.user.from_extid(self.game, self.version, extid)
        if userid is not None:
            lobbies = self.data.local.lobby.get_all_lobbies(self.game, self.version)
            for user, lobby in lobbies:
                if limit <= 0:
                    break

                if user == userid:
                    # If we have our own lobby, don't return it
                    continue
                if ver != lobby.get_int("ver"):
                    # Don't return lobby data for different versions
                    continue

                profile = self.get_profile(user)
                info = self.data.local.lobby.get_play_session_info(
                    self.game, self.version, userid
                )
                if profile is None or info is None:
                    # No profile info, don't return this lobby
                    return root

                e = Node.void("e")
                root.add_child(e)
                e.add_child(Node.s32("eid", lobby.get_int("id")))
                e.add_child(Node.u16("mid", lobby.get_int("mid")))
                e.add_child(Node.u8("ng", lobby.get_int("ng")))
                e.add_child(Node.s32("uid", profile.extid))
                e.add_child(Node.s32("uattr", profile.get_int("uattr")))
                e.add_child(Node.string("pn", profile.get_str("name")))
                e.add_child(Node.s32("plyid", info.get_int("id")))
                e.add_child(Node.s16("mg", profile.get_int("mg")))
                e.add_child(Node.s32("mopt", lobby.get_int("mopt")))
                e.add_child(Node.string("lid", lobby.get_str("lid")))
                e.add_child(Node.string("sn", lobby.get_str("sn")))
                e.add_child(Node.u8("pref", lobby.get_int("pref")))
                e.add_child(Node.s8("stg", lobby.get_int("stg")))
                e.add_child(Node.s8("pside", lobby.get_int("pside")))
                e.add_child(Node.s16("eatime", lobby.get_int("eatime")))
                e.add_child(Node.u8_array("ga", lobby.get_int_array("ga", 4)))
                e.add_child(Node.u16("gp", lobby.get_int("gp")))
                e.add_child(Node.u8_array("la", lobby.get_int_array("la", 4)))
                e.add_child(Node.u8("ver", lobby.get_int("ver")))
                e.add_child(Node.s8("tension", lobby.get_int("tension")))

                limit = limit - 1

        return root

    def handle_lobby_rb4delete_request(self, request: Node) -> Node:
        eid = request.child_value("eid")
        self.data.local.lobby.destroy_lobby(eid)
        return Node.void("lobby")

    def handle_shop_rb4setting_write_request(self, request: Node) -> Node:
        return Node.void("shop")

    def handle_shop_rb4info_write_request(self, request: Node) -> Node:
        self.update_machine_name(request.child_value("sinfo/nm"))
        self.update_machine_data(
            {
                "close": request.child_value("sinfo/cl_enbl"),
                "hour": request.child_value("sinfo/cl_h"),
                "minute": request.child_value("sinfo/cl_m"),
                "pref": request.child_value("sinfo/prf"),
            }
        )
        return Node.void("shop")

    def __add_event_info(self, root: Node) -> None:
        event_ctrl = Node.void("event_ctrl")
        root.add_child(event_ctrl)
        # Contains zero or more nodes like:
        # <data>
        #     <type __type="s32">any</type>
        #     <index __type="s32">any</phase>
        #     <value __type="s32">any</phase>
        #     <value2 __type="s32">any</phase>
        #     <start_time __type="s32">any</phase>
        #     <end_time __type="s32">any</phase>
        # </data>

        item_lock_ctrl = Node.void("item_lock_ctrl")
        root.add_child(item_lock_ctrl)
        # Contains zero or more nodes like:
        # <item>
        #     <type __type="u8">any</type>
        #     <id __type="u16">any</id>
        #     <param __type="u16">0-3</param>
        # </item>

    def __add_shop_score(self, root: Node) -> None:
        shop_score = Node.void("shop_score")
        root.add_child(shop_score)
        today = Node.void("today")
        shop_score.add_child(today)
        yesterday = Node.void("yesterday")
        shop_score.add_child(yesterday)

        all_profiles = self.data.local.user.get_all_profiles(self.game, self.version)
        all_attempts = self.data.local.music.get_all_attempts(
            self.game,
            self.version,
            timelimit=(Time.beginning_of_today() - Time.SECONDS_IN_DAY),
        )
        machine = self.data.local.machine.get_machine(self.config.machine.pcbid)
        if machine.arcade is not None:
            lids = [
                machine.id
                for machine in self.data.local.machine.get_all_machines(machine.arcade)
            ]
        else:
            lids = [machine.id]

        relevant_profiles = [
            profile for profile in all_profiles if profile[1].get_int("lid", -1) in lids
        ]

        for rootnode, timeoffset in [
            (today, 0),
            (yesterday, Time.SECONDS_IN_DAY),
        ]:
            # Grab all attempts made in the relevant day
            relevant_attempts = [
                attempt
                for attempt in all_attempts
                if (
                    attempt[1].timestamp >= (Time.beginning_of_today() - timeoffset)
                    and attempt[1].timestamp <= (Time.end_of_today() - timeoffset)
                )
            ]

            # Calculate scores based on attempt
            scores_by_user: Dict[UserID, Dict[int, Dict[int, Attempt]]] = {}
            for userid, attempt in relevant_attempts:
                if userid not in scores_by_user:
                    scores_by_user[userid] = {}
                if attempt.id not in scores_by_user[userid]:
                    scores_by_user[userid][attempt.id] = {}
                if attempt.chart not in scores_by_user[userid][attempt.id]:
                    # No high score for this yet, just use this attempt
                    scores_by_user[userid][attempt.id][attempt.chart] = attempt
                else:
                    # If this attempt is better than the stored one, replace it
                    if (
                        scores_by_user[userid][attempt.id][attempt.chart].points
                        < attempt.points
                    ):
                        scores_by_user[userid][attempt.id][attempt.chart] = attempt

            # Calculate points earned by user in the day
            points_by_user: Dict[UserID, int] = {}
            for userid in scores_by_user:
                points_by_user[userid] = 0
                for mid in scores_by_user[userid]:
                    for chart in scores_by_user[userid][mid]:
                        points_by_user[userid] = (
                            points_by_user[userid]
                            + scores_by_user[userid][mid][chart].points
                        )

            # Output that day's earned points
            for userid, profile in relevant_profiles:
                data = Node.void("data")
                rootnode.add_child(data)
                data.add_child(
                    Node.s16(
                        "day_id", int((Time.now() - timeoffset) / Time.SECONDS_IN_DAY)
                    )
                )
                data.add_child(Node.s32("user_id", profile.extid))
                data.add_child(
                    Node.s16("icon_id", profile.get_dict("config").get_int("icon_id"))
                )
                data.add_child(
                    Node.s16("point", min(points_by_user.get(userid, 0), 32767))
                )
                data.add_child(Node.s32("update_time", Time.now()))
                data.add_child(Node.string("name", profile.get_str("name")))

            rootnode.add_child(
                Node.s32("timestamp", Time.beginning_of_today() - timeoffset)
            )

    def handle_info_rb4common_request(self, request: Node) -> Node:
        root = Node.void("info")
        self.__add_event_info(root)
        self.__add_shop_score(root)

        return root

    def handle_info_rb4ranking_request(self, request: Node) -> Node:
        version = request.child_value("ver")

        root = Node.void("info")
        root.add_child(Node.s32("ver", version))
        ranking = Node.void("ranking")
        root.add_child(ranking)

        def add_hitchart(
            name: str, start: int, end: int, hitchart: List[Tuple[int, int]]
        ) -> None:
            base = Node.void(name)
            ranking.add_child(base)
            base.add_child(Node.s32("bt", start))
            base.add_child(Node.s32("et", end))
            new = Node.void("new")
            base.add_child(new)

            for mid, plays in hitchart:
                d = Node.void("d")
                new.add_child(d)
                d.add_child(Node.s16("mid", mid))
                d.add_child(Node.s32("cnt", plays))

        # Weekly hit chart
        add_hitchart(
            "weekly",
            Time.now() - Time.SECONDS_IN_WEEK,
            Time.now(),
            self.data.local.music.get_hit_chart(self.game, self.version, 1024, 7),
        )

        # Monthly hit chart
        add_hitchart(
            "monthly",
            Time.now() - Time.SECONDS_IN_DAY * 30,
            Time.now(),
            self.data.local.music.get_hit_chart(self.game, self.version, 1024, 30),
        )

        # All time hit chart
        add_hitchart(
            "total",
            Time.now() - Time.SECONDS_IN_DAY * 365,
            Time.now(),
            self.data.local.music.get_hit_chart(self.game, self.version, 1024, 365),
        )

        return root

    def handle_info_rb4shop_score_ranking_request(self, request: Node) -> Node:
        start_music_id = request.child_value("min")
        end_music_id = request.child_value("max")

        root = Node.void("info")
        shop_score = Node.void("shop_score")
        root.add_child(shop_score)
        shop_score.add_child(Node.s32("time", Time.now()))

        profiles: Dict[UserID, Profile] = {}
        for songid in range(start_music_id, end_music_id + 1):
            allscores = self.data.local.music.get_all_scores(
                self.game,
                self.version,
                songid=songid,
            )

            for ng in [
                self.CHART_TYPE_BASIC,
                self.CHART_TYPE_MEDIUM,
                self.CHART_TYPE_HARD,
                self.CHART_TYPE_SPECIAL,
            ]:
                scores = sorted(
                    [score for score in allscores if score[1].chart == ng],
                    key=lambda score: score[1].points,
                    reverse=True,
                )

                for i in range(len(scores)):
                    userid, score = scores[i]
                    if userid not in profiles:
                        profiles[userid] = self.get_any_profile(userid)
                    profile = profiles[userid]

                    data = Node.void("data")
                    shop_score.add_child(data)
                    data.add_child(Node.s32("rank", i + 1))
                    data.add_child(Node.s16("music_id", songid))
                    data.add_child(Node.s8("note_grade", score.chart))
                    data.add_child(
                        Node.s8(
                            "clear_type",
                            self.__db_to_game_clear_type(
                                score.data.get_int("clear_type")
                            ),
                        )
                    )
                    data.add_child(Node.s32("user_id", profile.extid))
                    data.add_child(
                        Node.s16(
                            "icon_id", profile.get_dict("config").get_int("icon_id")
                        )
                    )
                    data.add_child(Node.s32("score", score.points))
                    data.add_child(Node.s32("time", score.timestamp))
                    data.add_child(Node.string("name", profile.get_str("name")))

        return root

    def handle_info_rb4pzlcmt_read_request(self, request: Node) -> Node:
        extid = request.child_value("uid")
        locid = ID.parse_machine_id(request.child_value("lid"))
        limit = request.child_value("limit")
        userid = self.data.remote.user.from_extid(self.game, self.version, extid)

        comments = [
            achievement
            for achievement in self.data.local.user.get_all_time_based_achievements(
                self.game, self.version
            )
            if achievement[1].type == "puzzle_comment"
        ]
        comments.sort(key=lambda x: x[1].timestamp, reverse=True)
        favorites = [comment for comment in comments if comment[0] == userid]
        locationcomments = [
            comment for comment in comments if comment[1].data.get_int("locid") == locid
        ]

        # Cap all comment blocks to the limit
        if limit >= 0:
            comments = comments[:limit]
            favorites = favorites[:limit]
            locationcomments = locationcomments[:limit]

        root = Node.void("info")
        comment = Node.void("comment")
        root.add_child(comment)
        comment.add_child(Node.s32("time", Time.now()))

        # Mapping of profiles to userIDs
        uid_mapping = {
            uid: prof for (uid, prof) in self.get_any_profiles([c[0] for c in comments])
        }

        # Handle anonymous comments by returning a default profile
        uid_mapping[UserID(0)] = Profile(
            self.game,
            self.version,
            "",
            0,
            {"name": "ＰＬＡＹＥＲ"},
        )

        def add_comments(name: str, selected: List[Tuple[UserID, Achievement]]) -> None:
            for uid, ach in selected:
                cmnt = Node.void(name)
                root.add_child(cmnt)
                cmnt.add_child(Node.s32("uid", uid_mapping[uid].extid))
                cmnt.add_child(Node.string("name", uid_mapping[uid].get_str("name")))
                cmnt.add_child(Node.s16("icon", ach.data.get_int("icon")))
                cmnt.add_child(Node.s8("bln", ach.data.get_int("bln")))
                cmnt.add_child(
                    Node.string("lid", ID.format_machine_id(ach.data.get_int("locid")))
                )
                cmnt.add_child(Node.s8("pref", ach.data.get_int("prefecture")))
                cmnt.add_child(Node.s32("time", ach.timestamp))
                cmnt.add_child(Node.string("comment", ach.data.get_str("comment")))
                cmnt.add_child(Node.bool("is_tweet", ach.data.get_bool("tweet")))

        # Add all comments
        add_comments("c", comments)

        # Add personal comments (favorites)
        add_comments("cf", favorites)

        # Add location comments
        add_comments("cs", locationcomments)

        return root

    def handle_info_rb4pzlcmt_write_request(self, request: Node) -> Node:
        extid = request.child_value("uid")
        userid = self.data.remote.user.from_extid(self.game, self.version, extid)
        if userid is None:
            # Anonymous comment
            userid = UserID(0)

        icon = request.child_value("icon")
        bln = request.child_value("bln")
        locid = ID.parse_machine_id(request.child_value("lid"))
        prefecture = request.child_value("pref")
        comment = request.child_value("comment")
        is_tweet = request.child_value("is_tweet")

        # Link comment to user's profile
        self.data.local.user.put_time_based_achievement(
            self.game,
            self.version,
            userid,
            0,  # We never have an ID for this, since comments are add-only
            "puzzle_comment",
            {
                "icon": icon,
                "bln": bln,
                "locid": locid,
                "prefecture": prefecture,
                "comment": comment,
                "tweet": is_tweet,
            },
        )

        return Node.void("info")

    def handle_player_rb4start_request(self, request: Node) -> Node:
        root = Node.void("player")

        # Create a new play session based on info from the request
        refid = request.child_value("rid")
        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
        if userid is not None:
            self.data.local.lobby.put_play_session_info(
                self.game,
                self.version,
                userid,
                {
                    "ga": request.child_value("ga"),
                    "gp": request.child_value("gp"),
                    "la": request.child_value("la"),
                    "pnid": request.child_value("pnid"),
                },
            )
            info = self.data.local.lobby.get_play_session_info(
                self.game,
                self.version,
                userid,
            )
            if info is not None:
                play_id = info.get_int("id")
            else:
                play_id = 0
        else:
            play_id = 0

        # Session stuff, and resend global defaults
        root.add_child(Node.s32("plyid", play_id))
        root.add_child(Node.u64("start_time", Time.now() * 1000))
        self.__add_event_info(root)

        return root

    def handle_player_rb4end_request(self, request: Node) -> Node:
        # Destroy play session based on info from the request
        refid = request.child_value("rid")
        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
        if userid is not None:
            # Kill any lingering lobbies by this user
            lobby = self.data.local.lobby.get_lobby(
                self.game,
                self.version,
                userid,
            )
            if lobby is not None:
                self.data.local.lobby.destroy_lobby(lobby.get_int("id"))
            self.data.local.lobby.destroy_play_session_info(
                self.game, self.version, userid
            )

        return Node.void("player")

    def handle_player_rb4readepisode_request(self, request: Node) -> Node:
        extid = request.child_value("user_id")
        userid = self.data.remote.user.from_extid(self.game, self.version, extid)
        if userid is not None:
            achievements = self.data.local.user.get_achievements(
                self.game, self.version, userid
            )
        else:
            achievements = []

        root = Node.void("player")
        pdata = Node.void("pdata")
        root.add_child(pdata)
        episode = Node.void("episode")
        pdata.add_child(episode)

        for achievement in achievements:
            if achievement.type != "episode":
                continue

            info = Node.void("info")
            episode.add_child(info)
            info.add_child(Node.s32("user_id", extid))
            info.add_child(Node.u8("type", achievement.id))
            info.add_child(Node.u16("value0", achievement.data.get_int("value0")))
            info.add_child(Node.u16("value1", achievement.data.get_int("value1")))
            info.add_child(Node.string("text", achievement.data.get_str("text")))
            info.add_child(Node.s32("time", achievement.data.get_int("time")))

        return root

    def handle_player_rb4readscore_request(self, request: Node) -> Node:
        refid = request.child_value("rid")
        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
        if userid is None:
            scores: List[Score] = []
        else:
            scores = self.data.remote.music.get_scores(self.game, self.version, userid)

        root = Node.void("player")
        pdata = Node.void("pdata")
        root.add_child(pdata)

        record = Node.void("record")
        pdata.add_child(record)
        record_old = Node.void("record_old")
        pdata.add_child(record_old)

        for score in scores:
            rec = Node.void("rec")
            record.add_child(rec)
            rec.add_child(Node.s16("mid", score.id))
            rec.add_child(Node.s8("ntgrd", score.chart))
            rec.add_child(Node.s32("pc", score.plays))
            rec.add_child(
                Node.s8(
                    "ct", self.__db_to_game_clear_type(score.data.get_int("clear_type"))
                )
            )
            rec.add_child(Node.s16("ar", score.data.get_int("achievement_rate")))
            rec.add_child(Node.s16("scr", score.points))
            rec.add_child(Node.s16("ms", score.data.get_int("miss_count")))
            rec.add_child(
                Node.s16(
                    "param",
                    self.__db_to_game_combo_type(score.data.get_int("combo_type"))
                    + score.data.get_int("param"),
                )
            )
            rec.add_child(Node.s32("bscrt", score.timestamp))
            rec.add_child(
                Node.s32("bart", score.data.get_int("best_achievement_rate_time"))
            )
            rec.add_child(Node.s32("bctt", score.data.get_int("best_clear_type_time")))
            rec.add_child(Node.s32("bmst", score.data.get_int("best_miss_count_time")))
            rec.add_child(Node.s32("time", score.data.get_int("last_played_time")))

        return root

    def handle_player_rb4selectscore_request(self, request: Node) -> Node:
        extid = request.child_value("uid")
        songid = request.child_value("music_id")
        chart = request.child_value("note_grade")
        userid = self.data.remote.user.from_extid(self.game, self.version, extid)
        if userid is None:
            score = None
            profile = None
        else:
            score = self.data.remote.music.get_score(
                self.game, self.version, userid, songid, chart
            )
            profile = self.get_any_profile(userid)

        root = Node.void("player")
        if score is not None and profile is not None:
            player_select_score = Node.void("player_select_score")
            root.add_child(player_select_score)

            player_select_score.add_child(Node.s32("user_id", extid))
            player_select_score.add_child(Node.string("name", profile.get_str("name")))
            player_select_score.add_child(Node.s32("m_score", score.points))
            player_select_score.add_child(Node.s32("m_scoreTime", score.timestamp))
            player_select_score.add_child(
                Node.s16("m_iconID", profile.get_dict("config").get_int("icon_id"))
            )
        return root

    def handle_player_rbsvLinkageSave_request(self, request: Node) -> Node:
        # I think this is ReflecBeat/SoundVoltex linkage save, and I
        # am somewhat convinced that PK/BN is for packets/blocks, but
        # whatever.
        root = Node.void("player")
        root.add_child(Node.s32("before_pk_value", -1))
        root.add_child(Node.s32("after_pk_value", -1))
        root.add_child(Node.s32("before_bn_value", -1))
        root.add_child(Node.s32("after_bn_value", -1))
        return root

    def handle_player_rb4total_bestallrank_read_request(self, request: Node) -> Node:
        # This gives us a 6-integer array mapping to user scores for the following:
        # [total score, basic chart score, medium chart score, hard chart score,
        # special chart score, new songs score].
        # It appears to return several 6-array values similar to the following:
        # <score>
        #     <rank __type="s32" __count="6">1 2 3 4 5 6</rank>
        #     <score __type="s32" __count="6">101 102 103 104 105 106</score>
        #     <allrank __type="s32" __count="6">7 8 9 10 11 12</allrank>
        # </score>
        # The first 'rank' is the displayed value for the six categories. The
        # second and third values appear unused in-game. I think this is supposed
        # to give a player the idea of what ranking they are on the server for
        # various scores.
        current_scores = request.child_value("score")

        # First, grab all scores on the network for this version, and all songs
        # available so we know which songs are new to this version of the game.
        all_scores = self.data.remote.music.get_all_scores(self.game, self.version)
        all_songs = self.data.local.music.get_all_songs(self.game, self.version)

        # Figure out what song IDs are new
        new_songs = {
            song.id
            for song in all_songs
            if song.data.get_int("folder", 0) == self.version
        }

        # Now grab all participating users that had scores
        all_users = {userid for (userid, score) in all_scores}

        # Now, group the scores by user, so we can add up the totals, only including
        # scores where the user at least cleared the song.
        scores_by_user = {
            userid: [
                score
                for (uid, score) in all_scores
                if uid == userid
                and score.data.get_int("clear_type") >= self.CLEAR_TYPE_CLEARED
            ]
            for userid in all_users
        }

        # Now, sum up the scores into the six categories that the game expects.
        total_scores = sorted(
            [
                sum([score.points for score in scores])
                for userid, scores in scores_by_user.items()
            ],
            reverse=True,
        )
        basic_scores = sorted(
            [
                sum(
                    [
                        score.points
                        for score in scores
                        if score.chart == self.CHART_TYPE_BASIC
                    ]
                )
                for userid, scores in scores_by_user.items()
            ],
            reverse=True,
        )
        medium_scores = sorted(
            [
                sum(
                    [
                        score.points
                        for score in scores
                        if score.chart == self.CHART_TYPE_MEDIUM
                    ]
                )
                for userid, scores in scores_by_user.items()
            ],
            reverse=True,
        )
        hard_scores = sorted(
            [
                sum(
                    [
                        score.points
                        for score in scores
                        if score.chart == self.CHART_TYPE_HARD
                    ]
                )
                for userid, scores in scores_by_user.items()
            ],
            reverse=True,
        )
        special_scores = sorted(
            [
                sum(
                    [
                        score.points
                        for score in scores
                        if score.chart == self.CHART_TYPE_SPECIAL
                    ]
                )
                for userid, scores in scores_by_user.items()
            ],
            reverse=True,
        )
        new_scores = sorted(
            [
                sum([score.points for score in scores if score.id in new_songs])
                for userid, scores in scores_by_user.items()
            ],
            reverse=True,
        )

        # Guarantee that a zero score is at the end of every list, so that it makes
        # the algorithm for figuring out place have no edge case.
        total_scores.append(0)
        basic_scores.append(0)
        medium_scores.append(0)
        hard_scores.append(0)
        special_scores.append(0)
        new_scores.append(0)

        # Now, figure out where we fit based on the scores sent from the game.
        user_place = [1, 1, 1, 1, 1, 1]
        which_score = [
            total_scores,
            basic_scores,
            medium_scores,
            hard_scores,
            special_scores,
            new_scores,
        ]
        for i in range(len(user_place)):
            current_score = current_scores[i]
            scores = which_score[i]
            for score in scores:
                if current_score >= score:
                    break
                user_place[i] = user_place[i] + 1

        root = Node.void("player")
        scorenode = Node.void("score")
        root.add_child(scorenode)
        scorenode.add_child(Node.s32_array("rank", user_place))
        scorenode.add_child(Node.s32_array("score", [0] * 6))
        scorenode.add_child(Node.s32_array("allrank", [len(total_scores)] * 6))
        return root

    def handle_player_rb4delete_request(self, request: Node) -> Node:
        return Node.void("player")

    def handle_player_rb4read_request(self, request: Node) -> Node:
        refid = request.child_value("rid")
        profile = self.get_profile_by_refid(refid)
        if profile:
            return profile
        return Node.void("player")

    def handle_player_rb4succeed_request(self, request: Node) -> Node:
        refid = request.child_value("rid")
        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
        if userid is not None:
            previous_version = self.previous_version()
            profile = previous_version.get_profile(userid)
            achievements = self.data.local.user.get_achievements(
                previous_version.game, previous_version.version, userid
            )
            scores = self.data.remote.music.get_scores(
                previous_version.game, previous_version.version, userid
            )
        else:
            profile = None

        root = Node.void("player")

        if profile is None:
            # Return empty succeed to say this is new
            root.add_child(Node.string("name", ""))
            root.add_child(Node.s16("lv", -1))
            root.add_child(Node.s32("exp", -1))
            root.add_child(Node.s32("grd", -1))
            root.add_child(Node.s32("ap", -1))
            root.add_child(Node.s32("money", -1))
            root.add_child(Node.void("released"))
            root.add_child(Node.void("mrecord"))
        else:
            # Return previous profile formatted to say this is data succession
            root.add_child(Node.string("name", profile.get_str("name")))
            root.add_child(Node.s16("lv", profile.get_int("lvl")))
            root.add_child(Node.s32("exp", profile.get_int("exp")))
            root.add_child(Node.s32("grd", profile.get_int("mg")))  # This is a guess
            root.add_child(Node.s32("ap", profile.get_int("ap")))
            root.add_child(Node.s32("money", 0))

            released = Node.void("released")
            root.add_child(released)
            for item in achievements:
                if item.type != "item_0":
                    continue

                released.add_child(Node.s16("i", item.id))

            mrecord = Node.void("mrecord")
            root.add_child(mrecord)
            for score in scores:
                mrec = Node.void("mrec")
                mrecord.add_child(mrec)
                mrec.add_child(Node.s16("mid", score.id))
                mrec.add_child(Node.s8("ntgrd", score.chart))
                mrec.add_child(Node.s32("pc", score.plays))
                mrec.add_child(
                    Node.s8(
                        "ct",
                        self.__db_to_game_clear_type(score.data.get_int("clear_type")),
                    )
                )
                mrec.add_child(Node.s16("ar", score.data.get_int("achievement_rate")))
                mrec.add_child(Node.s16("scr", score.points))
                mrec.add_child(Node.s16("ms", score.data.get_int("miss_count")))
                mrec.add_child(Node.u16("ver", 0))
                mrec.add_child(Node.s32("bst", score.timestamp))
                mrec.add_child(
                    Node.s32("bat", score.data.get_int("best_achievement_rate_time"))
                )
                mrec.add_child(
                    Node.s32("bct", score.data.get_int("best_clear_type_time"))
                )
                mrec.add_child(
                    Node.s32("bmt", score.data.get_int("best_miss_count_time"))
                )

        return root

    def handle_player_rb4write_request(self, request: Node) -> Node:
        refid = request.child_value("pdata/account/rid")
        profile = self.put_profile_by_refid(refid, request)
        root = Node.void("player")

        if profile is None:
            root.add_child(Node.s32("uid", 0))
        else:
            root.add_child(Node.s32("uid", profile.extid))
        return root

    def format_profile(self, userid: UserID, profile: Profile) -> Node:
        statistics = self.get_play_statistics(userid)
        game_config = self.get_game_config()
        achievements = self.data.local.user.get_achievements(
            self.game, self.version, userid
        )
        links = self.data.local.user.get_links(self.game, self.version, userid)
        root = Node.void("player")
        pdata = Node.void("pdata")
        root.add_child(pdata)

        # Account info
        account = Node.void("account")
        pdata.add_child(account)
        account.add_child(Node.s32("usrid", profile.extid))
        account.add_child(Node.s32("tpc", statistics.total_plays))
        account.add_child(Node.s32("dpc", statistics.today_plays))
        account.add_child(Node.s32("crd", 1))
        account.add_child(Node.s32("brd", 1))
        account.add_child(Node.s32("tdc", statistics.total_days))
        account.add_child(Node.s32("intrvld", 0))
        account.add_child(Node.s16("ver", 1))
        account.add_child(Node.u64("pst", 0))
        account.add_child(Node.u64("st", Time.now() * 1000))
        account.add_child(Node.u8("debutVer", 2))

        # Base profile info
        base = Node.void("base")
        pdata.add_child(base)
        base.add_child(Node.string("name", profile.get_str("name")))
        base.add_child(Node.s32("exp", profile.get_int("exp")))
        base.add_child(Node.s32("lv", profile.get_int("lvl")))
        base.add_child(Node.s32("mg", profile.get_int("mg")))
        base.add_child(Node.s32("ap", profile.get_int("ap")))
        base.add_child(Node.string("cmnt", ""))
        base.add_child(Node.s32("uattr", profile.get_int("uattr")))
        base.add_child(Node.s32("money", profile.get_int("money")))
        base.add_child(Node.s32("tbs", -1))
        base.add_child(Node.s32("tbs_r", -1))
        base.add_child(Node.s32("tbgs", -1))
        base.add_child(Node.s32("tbgs_r", -1))
        base.add_child(Node.s32("tbms", -1))
        base.add_child(Node.s32("tbms_r", -1))
        base.add_child(Node.s32("qe_win", -1))
        base.add_child(Node.s32("qe_legend", -1))
        base.add_child(Node.s32("qe2_win", -1))
        base.add_child(Node.s32("qe2_legend", -1))
        base.add_child(Node.s32("qe3_win", -1))
        base.add_child(Node.s32("qe3_legend", -1))
        base.add_child(Node.s16_array("mlog", [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1]))
        base.add_child(Node.s32("class", profile.get_int("class")))
        base.add_child(Node.s32("class_ar", profile.get_int("class_ar")))
        base.add_child(Node.s32("getrfl", -1))
        base.add_child(Node.s32("upper_pt", profile.get_int("upper_pt")))

        # Rivals
        rival = Node.void("rival")
        pdata.add_child(rival)
        slotid = 0
        for link in links:
            if link.type != "rival":
                continue

            rprofile = self.get_profile(link.other_userid)
            if rprofile is None:
                continue
            lobbyinfo = self.data.local.lobby.get_play_session_info(
                self.game, self.version, link.other_userid
            )
            if lobbyinfo is None:
                lobbyinfo = ValidatedDict()

            r = Node.void("r")
            rival.add_child(r)
            r.add_child(Node.s32("slot_id", slotid))
            r.add_child(Node.s32("id", rprofile.extid))
            r.add_child(Node.string("name", rprofile.get_str("name")))
            r.add_child(Node.s32("icon", profile.get_dict("config").get_int("icon_id")))
            r.add_child(Node.s32("m_level", profile.get_int("mg")))
            r.add_child(Node.s32("class", profile.get_int("class")))
            r.add_child(Node.s32("class_ar", profile.get_int("class_ar")))
            r.add_child(Node.bool("friend", True))
            r.add_child(Node.bool("target", False))
            r.add_child(Node.u32("time", lobbyinfo.get_int("time")))
            r.add_child(Node.u8_array("ga", lobbyinfo.get_int_array("ga", 4)))
            r.add_child(Node.u16("gp", lobbyinfo.get_int("gp")))
            r.add_child(Node.u8_array("ipn", lobbyinfo.get_int_array("la", 4)))
            r.add_child(Node.u8_array("pnid", lobbyinfo.get_int_array("pnid", 16)))
            slotid = slotid + 1

        # Stamps
        stamp = Node.void("stamp")
        stampdict = profile.get_dict("stamp")
        pdata.add_child(stamp)
        stamp.add_child(
            Node.s32_array("stmpcnt", stampdict.get_int_array("stmpcnt", 10))
        )
        stamp.add_child(Node.s64("area", stampdict.get_int("area")))
        stamp.add_child(Node.s64("prfvst", stampdict.get_int("prfvst")))

        # Configuration
        configdict = profile.get_dict("config")
        config = Node.void("config")
        pdata.add_child(config)
        config.add_child(Node.u8("msel_bgm", configdict.get_int("msel_bgm")))
        config.add_child(
            Node.u8("narrowdown_type", configdict.get_int("narrowdown_type"))
        )
        config.add_child(Node.s16("icon_id", configdict.get_int("icon_id")))
        config.add_child(Node.s16("byword_0", configdict.get_int("byword_0")))
        config.add_child(Node.s16("byword_1", configdict.get_int("byword_1")))
        config.add_child(
            Node.bool("is_auto_byword_0", configdict.get_bool("is_auto_byword_0"))
        )
        config.add_child(
            Node.bool("is_auto_byword_1", configdict.get_bool("is_auto_byword_1"))
        )
        config.add_child(Node.u8("mrec_type", configdict.get_int("mrec_type")))
        config.add_child(Node.u8("tab_sel", configdict.get_int("tab_sel")))
        config.add_child(Node.u8("card_disp", configdict.get_int("card_disp")))
        config.add_child(
            Node.u8("score_tab_disp", configdict.get_int("score_tab_disp"))
        )
        config.add_child(
            Node.s16("last_music_id", configdict.get_int("last_music_id", -1))
        )
        config.add_child(
            Node.u8("last_note_grade", configdict.get_int("last_note_grade"))
        )
        config.add_child(Node.u8("sort_type", configdict.get_int("sort_type")))
        config.add_child(
            Node.u8("rival_panel_type", configdict.get_int("rival_panel_type"))
        )
        config.add_child(
            Node.u64("random_entry_work", configdict.get_int("random_entry_work"))
        )
        config.add_child(
            Node.u64("custom_folder_work", configdict.get_int("custom_folder_work"))
        )
        config.add_child(Node.u8("folder_type", configdict.get_int("folder_type")))
        config.add_child(
            Node.u8("folder_lamp_type", configdict.get_int("folder_lamp_type"))
        )
        config.add_child(Node.bool("is_tweet", configdict.get_bool("is_tweet")))
        config.add_child(
            Node.bool("is_link_twitter", configdict.get_bool("is_link_twitter"))
        )

        # Customizations
        customdict = profile.get_dict("custom")
        custom = Node.void("custom")
        pdata.add_child(custom)
        custom.add_child(Node.u8("st_shot", customdict.get_int("st_shot")))
        custom.add_child(Node.u8("st_frame", customdict.get_int("st_frame")))
        custom.add_child(Node.u8("st_expl", customdict.get_int("st_expl")))
        custom.add_child(Node.u8("st_bg", customdict.get_int("st_bg")))
        custom.add_child(Node.u8("st_shot_vol", customdict.get_int("st_shot_vol")))
        custom.add_child(Node.u8("st_bg_bri", customdict.get_int("st_bg_bri")))
        custom.add_child(Node.u8("st_obj_size", customdict.get_int("st_obj_size")))
        custom.add_child(Node.u8("st_jr_gauge", customdict.get_int("st_jr_gauge")))
        custom.add_child(Node.u8("st_clr_gauge", customdict.get_int("st_clr_gauge")))
        custom.add_child(Node.u8("st_jdg_disp", customdict.get_int("st_jdg_disp")))
        custom.add_child(Node.u8("st_tm_disp", customdict.get_int("st_tm_disp")))
        custom.add_child(Node.u8("st_rnd", customdict.get_int("st_rnd")))
        custom.add_child(Node.u8("st_hazard", customdict.get_int("st_hazard")))
        custom.add_child(Node.u8("st_clr_cond", customdict.get_int("st_clr_cond")))
        custom.add_child(
            Node.s16_array("schat_0", customdict.get_int_array("schat_0", 10))
        )
        custom.add_child(
            Node.s16_array("schat_1", customdict.get_int_array("schat_1", 10))
        )
        custom.add_child(Node.u8("cheer_voice", customdict.get_int("cheer_voice")))
        custom.add_child(
            Node.u8("same_time_note_disp", customdict.get_int("same_time_note_disp"))
        )

        # Unlocks
        released = Node.void("released")
        pdata.add_child(released)

        for item in achievements:
            if item.type[:5] != "item_":
                continue
            itemtype = int(item.type[5:])
            if game_config.get_bool("force_unlock_songs") and itemtype == 0:
                # Don't echo unlocks when we're force unlocking, we'll do it later
                continue

            info = Node.void("info")
            released.add_child(info)
            info.add_child(Node.u8("type", itemtype))
            info.add_child(Node.u16("id", item.id))
            info.add_child(Node.u16("param", item.data.get_int("param")))

        if game_config.get_bool("force_unlock_songs"):
            ids: Dict[int, int] = {}
            songs = self.data.local.music.get_all_songs(self.game, self.version)
            for song in songs:
                if song.id not in ids:
                    ids[song.id] = 0

                if song.data.get_int("difficulty") > 0:
                    ids[song.id] = ids[song.id] | (1 << song.chart)

            for songid in ids:
                if ids[songid] == 0:
                    continue

                info = Node.void("info")
                released.add_child(info)
                info.add_child(Node.u8("type", 0))
                info.add_child(Node.u16("id", songid))
                info.add_child(Node.u16("param", ids[songid]))

        # Announcements
        announce = Node.void("announce")
        pdata.add_child(announce)

        for announcement in achievements:
            if announcement.type[:13] != "announcement_":
                continue
            announcementtype = int(announcement.type[13:])

            info = Node.void("info")
            announce.add_child(info)
            info.add_child(Node.u8("type", announcementtype))
            info.add_child(Node.u16("id", announcement.id))
            info.add_child(Node.u16("param", announcement.data.get_int("param")))
            info.add_child(
                Node.bool("bneedannounce", announcement.data.get_bool("need"))
            )

        # Dojo ranking return
        dojo = Node.void("dojo")
        pdata.add_child(dojo)

        for entry in achievements:
            if entry.type != "dojo":
                continue

            rec = Node.void("rec")
            dojo.add_child(rec)
            rec.add_child(Node.s32("class", entry.id))
            rec.add_child(Node.s32("clear_type", entry.data.get_int("clear_type")))
            rec.add_child(Node.s32("total_ar", entry.data.get_int("ar")))
            rec.add_child(Node.s32("total_score", entry.data.get_int("score")))
            rec.add_child(Node.s32("play_count", entry.data.get_int("plays")))
            rec.add_child(
                Node.s32("last_play_time", entry.data.get_int("play_timestamp"))
            )
            rec.add_child(
                Node.s32("record_update_time", entry.data.get_int("record_timestamp"))
            )
            rec.add_child(Node.s32("rank", 0))

        # Player Parameters
        player_param = Node.void("player_param")
        pdata.add_child(player_param)

        for param in achievements:
            if param.type[:13] != "player_param_":
                continue
            itemtype = int(param.type[13:])

            itemnode = Node.void("item")
            player_param.add_child(itemnode)
            itemnode.add_child(Node.s32("type", itemtype))
            itemnode.add_child(Node.s32("bank", param.id))
            itemnode.add_child(
                Node.s32_array("data", param.data.get_int_array("data", 256))
            )

        # Shop score for players
        self.__add_shop_score(pdata)

        # Quest data
        questdict = profile.get_dict("quest")
        quest = Node.void("quest")
        pdata.add_child(quest)
        quest.add_child(Node.s16("eye_color", questdict.get_int("eye_color")))
        quest.add_child(Node.s16("body_color", questdict.get_int("body_color")))
        quest.add_child(Node.s16("item", questdict.get_int("item")))
        quest.add_child(Node.string("comment", ""))

        # Derby settings
        derby = Node.void("derby")
        pdata.add_child(derby)
        derby.add_child(Node.bool("is_open", False))

        # Codebreaking stuff
        codebreaking = Node.void("codebreaking")
        pdata.add_child(codebreaking)
        codebreaking.add_child(Node.s32("cb_id", -1))
        codebreaking.add_child(Node.s32("cb_sub_id", -1))
        codebreaking.add_child(Node.s32("music_id", -1))
        codebreaking.add_child(Node.string("question", ""))

        # Unknown IIDX link crap
        iidx_linkage = Node.void("iidx_linkage")
        pdata.add_child(iidx_linkage)
        iidx_linkage.add_child(Node.s32("linkage_id", -1))
        iidx_linkage.add_child(Node.s32("phase", -1))
        iidx_linkage.add_child(Node.s64("long_bit_0", -1))
        iidx_linkage.add_child(Node.s64("long_bit_1", -1))
        iidx_linkage.add_child(Node.s64("long_bit_2", -1))
        iidx_linkage.add_child(Node.s64("long_bit_3", -1))
        iidx_linkage.add_child(Node.s64("long_bit_4", -1))
        iidx_linkage.add_child(Node.s64("long_bit_5", -1))
        iidx_linkage.add_child(Node.s32("add_0", -1))
        iidx_linkage.add_child(Node.s32("add_1", -1))
        iidx_linkage.add_child(Node.s32("add_2", -1))
        iidx_linkage.add_child(Node.s32("add_3", -1))

        # Unknown event crap
        pue = Node.void("pue")
        pdata.add_child(pue)
        pue.add_child(Node.s32("event_id", -1))
        pue.add_child(Node.s32("point", -1))
        pue.add_child(Node.s32("value0", -1))
        pue.add_child(Node.s32("value1", -1))
        pue.add_child(Node.s32("value2", -1))
        pue.add_child(Node.s32("value3", -1))
        pue.add_child(Node.s32("value4", -1))
        pue.add_child(Node.s32("start_time", -1))
        pue.add_child(Node.s32("end_time", -1))

        return root

    def unformat_profile(
        self, userid: UserID, request: Node, oldprofile: Profile
    ) -> Profile:
        game_config = self.get_game_config()
        newprofile = oldprofile.clone()

        # Save base player profile info
        newprofile.replace_int(
            "lid", ID.parse_machine_id(request.child_value("pdata/account/lid"))
        )
        newprofile.replace_str("name", request.child_value("pdata/base/name"))
        newprofile.replace_int("exp", request.child_value("pdata/base/exp"))
        newprofile.replace_int("lvl", request.child_value("pdata/base/lvl"))
        newprofile.replace_int("mg", request.child_value("pdata/base/mg"))
        newprofile.replace_int("ap", request.child_value("pdata/base/ap"))
        newprofile.replace_int("money", request.child_value("pdata/base/money"))
        newprofile.replace_int("class", request.child_value("pdata/base/class"))
        newprofile.replace_int("class_ar", request.child_value("pdata/base/class_ar"))
        newprofile.replace_int("upper_pt", request.child_value("pdata/base/upper_pt"))

        # Save stamps
        stampdict = newprofile.get_dict("stamp")
        stamp = request.child("pdata/stamp")
        if stamp:
            stampdict.replace_int_array("stmpcnt", 10, stamp.child_value("stmpcnt"))
            stampdict.replace_int("area", stamp.child_value("area"))
            stampdict.replace_int("prfvst", stamp.child_value("prfvst"))
        newprofile.replace_dict("stamp", stampdict)

        # Save quest stuff
        questdict = newprofile.get_dict("quest")
        quest = request.child("pdata/quest")
        if quest:
            questdict.replace_int("eye_color", quest.child_value("eye_color"))
            questdict.replace_int("body_color", quest.child_value("body_color"))
            questdict.replace_int("item", quest.child_value("item"))
        newprofile.replace_dict("quest", questdict)

        # Save player dojo
        dojo = request.child("pdata/dojo")
        if dojo:
            dojoid = dojo.child_value("class")
            clear_type = dojo.child_value("clear_type")
            ar = dojo.child_value("t_ar")
            score = dojo.child_value("t_score")

            # Figure out timestamp stuff
            data = (
                self.data.local.user.get_achievement(
                    self.game,
                    self.version,
                    userid,
                    dojoid,
                    "dojo",
                )
                or ValidatedDict()
            )

            if ar >= data.get_int("ar"):
                # We set a new achievement rate, keep the new values
                record_time = Time.now()
            else:
                # We didn't, keep the old values for achievement rate, but
                # override score and clear_type only if they were better.
                record_time = data.get_int("record_timestamp")
                ar = data.get_int("ar")
                score = max(score, data.get_int("score"))
                clear_type = max(clear_type, data.get_int("clear_type"))

            play_time = Time.now()
            plays = data.get_int("plays") + 1

            self.data.local.user.put_achievement(
                self.game,
                self.version,
                userid,
                dojoid,
                "dojo",
                {
                    "clear_type": clear_type,
                    "ar": ar,
                    "score": score,
                    "plays": plays,
                    "play_timestamp": play_time,
                    "record_timestamp": record_time,
                },
            )

        # Save player config
        configdict = newprofile.get_dict("config")
        config = request.child("pdata/config")
        if config:
            configdict.replace_int("msel_bgm", config.child_value("msel_bgm"))
            configdict.replace_int(
                "narrowdown_type", config.child_value("narrowdown_type")
            )
            configdict.replace_int("icon_id", config.child_value("icon_id"))
            configdict.replace_int("byword_0", config.child_value("byword_0"))
            configdict.replace_int("byword_1", config.child_value("byword_1"))
            configdict.replace_bool(
                "is_auto_byword_0", config.child_value("is_auto_byword_0")
            )
            configdict.replace_bool(
                "is_auto_byword_1", config.child_value("is_auto_byword_1")
            )
            configdict.replace_int("mrec_type", config.child_value("mrec_type"))
            configdict.replace_int("tab_sel", config.child_value("tab_sel"))
            configdict.replace_int("card_disp", config.child_value("card_disp"))
            configdict.replace_int(
                "score_tab_disp", config.child_value("score_tab_disp")
            )
            configdict.replace_int("last_music_id", config.child_value("last_music_id"))
            configdict.replace_int(
                "last_note_grade", config.child_value("last_note_grade")
            )
            configdict.replace_int("sort_type", config.child_value("sort_type"))
            configdict.replace_int(
                "rival_panel_type", config.child_value("rival_panel_type")
            )
            configdict.replace_int(
                "random_entry_work", config.child_value("random_entry_work")
            )
            configdict.replace_int(
                "custom_folder_work", config.child_value("custom_folder_work")
            )
            configdict.replace_int("folder_type", config.child_value("folder_type"))
            configdict.replace_int(
                "folder_lamp_type", config.child_value("folder_lamp_type")
            )
            configdict.replace_bool("is_tweet", config.child_value("is_tweet"))
            configdict.replace_bool(
                "is_link_twitter", config.child_value("is_link_twitter")
            )
        newprofile.replace_dict("config", configdict)

        # Save player custom settings
        customdict = newprofile.get_dict("custom")
        custom = request.child("pdata/custom")
        if custom:
            customdict.replace_int("st_shot", custom.child_value("st_shot"))
            customdict.replace_int("st_frame", custom.child_value("st_frame"))
            customdict.replace_int("st_expl", custom.child_value("st_expl"))
            customdict.replace_int("st_bg", custom.child_value("st_bg"))
            customdict.replace_int("st_shot_vol", custom.child_value("st_shot_vol"))
            customdict.replace_int("st_bg_bri", custom.child_value("st_bg_bri"))
            customdict.replace_int("st_obj_size", custom.child_value("st_obj_size"))
            customdict.replace_int("st_jr_gauge", custom.child_value("st_jr_gauge"))
            customdict.replace_int("st_clr_gauge", custom.child_value("st_clr_gauge"))
            customdict.replace_int("st_jdg_disp", custom.child_value("st_jdg_disp"))
            customdict.replace_int("st_tm_disp", custom.child_value("st_tm_disp"))
            customdict.replace_int("st_rnd", custom.child_value("st_rnd"))
            customdict.replace_int("st_hazard", custom.child_value("st_hazard"))
            customdict.replace_int("st_clr_cond", custom.child_value("st_clr_cond"))
            customdict.replace_int_array("schat_0", 10, custom.child_value("schat_0"))
            customdict.replace_int_array("schat_1", 10, custom.child_value("schat_1"))
            customdict.replace_int("cheer_voice", custom.child_value("cheer_voice"))
            customdict.replace_int(
                "same_time_note_disp", custom.child_value("same_time_note_disp")
            )
        newprofile.replace_dict("custom", customdict)

        # Save player parameter info
        params = request.child("pdata/player_param")
        if params:
            for child in params.children:
                if child.name != "item":
                    continue

                item_type = child.child_value("type")
                bank = child.child_value("bank")
                paramdata = child.child_value("data") or []
                while len(paramdata) < 256:
                    paramdata.append(0)
                self.data.local.user.put_achievement(
                    self.game,
                    self.version,
                    userid,
                    bank,
                    f"player_param_{item_type}",
                    {
                        "data": paramdata,
                    },
                )

        # Save player episode info
        episode = request.child("pdata/episode")
        if episode:
            for child in episode.children:
                if child.name != "info":
                    continue

                # I assume this is copypasta, but I want to be sure
                extid = child.child_value("user_id")
                if extid != newprofile.extid:
                    raise Exception(
                        f"Unexpected user ID, got {extid} expecting {newprofile.extid}"
                    )

                episode_type = child.child_value("type")
                episode_value0 = child.child_value("value0")
                episode_value1 = child.child_value("value1")
                episode_text = child.child_value("text")
                episode_time = child.child_value("time")
                self.data.local.user.put_achievement(
                    self.game,
                    self.version,
                    userid,
                    episode_type,
                    "episode",
                    {
                        "value0": episode_value0,
                        "value1": episode_value1,
                        "text": episode_text,
                        "time": episode_time,
                    },
                )

        # Save released info
        released = request.child("pdata/released")
        if released:
            for child in released.children:
                if child.name != "info":
                    continue

                item_id = child.child_value("id")
                item_type = child.child_value("type")
                param = child.child_value("param")
                if game_config.get_bool("force_unlock_songs") and item_type == 0:
                    # Don't save unlocks when we're force unlocking
                    continue

                self.data.local.user.put_achievement(
                    self.game,
                    self.version,
                    userid,
                    item_id,
                    f"item_{item_type}",
                    {
                        "param": param,
                    },
                )

        # Save announce info
        announce = request.child("pdata/announce")
        if announce:
            for child in announce.children:
                if child.name != "info":
                    continue

                announce_id = child.child_value("id")
                announce_type = child.child_value("type")
                param = child.child_value("param")
                need = child.child_value("bneedannounce")
                self.data.local.user.put_achievement(
                    self.game,
                    self.version,
                    userid,
                    announce_id,
                    f"announcement_{announce_type}",
                    {
                        "param": param,
                        "need": need,
                    },
                )

        # Grab any new rivals added during this play session
        rivalnode = request.child("pdata/rival")
        if rivalnode:
            for child in rivalnode.children:
                if child.name != "r":
                    continue

                extid = child.child_value("id")
                other_userid = self.data.remote.user.from_extid(
                    self.game, self.version, extid
                )
                if other_userid is None:
                    continue

                self.data.local.user.put_link(
                    self.game,
                    self.version,
                    userid,
                    "rival",
                    other_userid,
                    {},
                )

        # Grab any new records set during this play session
        songplays = request.child("pdata/stglog")
        if songplays:
            for child in songplays.children:
                if child.name != "log":
                    continue

                songid = child.child_value("mid")
                chart = child.child_value("ng")
                clear_type = child.child_value("ct")
                if songid == 0 and chart == 0 and clear_type == -1:
                    # Dummy song save during profile create
                    continue

                points = child.child_value("sc")
                achievement_rate = child.child_value("ar")
                param = child.child_value("param")
                miss_count = child.child_value("jt_ms")

                # Param is some random bits along with the combo type
                combo_type = param & 0x3
                param = param ^ combo_type

                clear_type = self.__game_to_db_clear_type(clear_type)
                combo_type = self.__game_to_db_combo_type(combo_type, miss_count)
                self.update_score(
                    userid,
                    songid,
                    chart,
                    points,
                    achievement_rate,
                    clear_type,
                    combo_type,
                    miss_count,
                    param=param,
                )

        # Keep track of play statistics
        self.update_play_statistics(userid)

        return newprofile