bemaniutils/bemani/backend/iidx/cannonballers.py

# vim: set fileencoding=utf-8
import random
import struct
from typing import Optional, Dict, Any, List, Tuple
from typing_extensions import Final

from bemani.backend.iidx.base import IIDXBase
from bemani.backend.iidx.course import IIDXCourse
from bemani.backend.iidx.sinobuz import IIDXSinobuz

from bemani.common import (
    Profile,
    ValidatedDict,
    VersionConstants,
    BroadcastConstants,
    Time,
    ID,
    intish,
)
from bemani.data import Data, UserID
from bemani.protocol import Node


class IIDXCannonBallers(IIDXCourse, IIDXBase):
    name: str = "Beatmania IIDX CANNON BALLERS"
    version: int = VersionConstants.IIDX_CANNON_BALLERS

    GAME_CLTYPE_SINGLE: Final[int] = 0
    GAME_CLTYPE_DOUBLE: Final[int] = 1

    DAN_STAGES: Final[int] = 4

    GAME_CLEAR_STATUS_NO_PLAY: Final[int] = 0
    GAME_CLEAR_STATUS_FAILED: Final[int] = 1
    GAME_CLEAR_STATUS_ASSIST_CLEAR: Final[int] = 2
    GAME_CLEAR_STATUS_EASY_CLEAR: Final[int] = 3
    GAME_CLEAR_STATUS_CLEAR: Final[int] = 4
    GAME_CLEAR_STATUS_HARD_CLEAR: Final[int] = 5
    GAME_CLEAR_STATUS_EX_HARD_CLEAR: Final[int] = 6
    GAME_CLEAR_STATUS_FULL_COMBO: Final[int] = 7

    GAME_GHOST_TYPE_RIVAL: Final[int] = 1
    GAME_GHOST_TYPE_GLOBAL_TOP: Final[int] = 2
    GAME_GHOST_TYPE_GLOBAL_AVERAGE: Final[int] = 3
    GAME_GHOST_TYPE_LOCAL_TOP: Final[int] = 4
    GAME_GHOST_TYPE_LOCAL_AVERAGE: Final[int] = 5
    GAME_GHOST_TYPE_DAN_TOP: Final[int] = 6
    GAME_GHOST_TYPE_DAN_AVERAGE: Final[int] = 7
    GAME_GHOST_TYPE_RIVAL_TOP: Final[int] = 8
    GAME_GHOST_TYPE_RIVAL_AVERAGE: Final[int] = 9

    GAME_GHOST_LENGTH: Final[int] = 64

    GAME_SP_DAN_RANK_7_KYU: Final[int] = 0
    GAME_SP_DAN_RANK_6_KYU: Final[int] = 1
    GAME_SP_DAN_RANK_5_KYU: Final[int] = 2
    GAME_SP_DAN_RANK_4_KYU: Final[int] = 3
    GAME_SP_DAN_RANK_3_KYU: Final[int] = 4
    GAME_SP_DAN_RANK_2_KYU: Final[int] = 5
    GAME_SP_DAN_RANK_1_KYU: Final[int] = 6
    GAME_SP_DAN_RANK_1_DAN: Final[int] = 7
    GAME_SP_DAN_RANK_2_DAN: Final[int] = 8
    GAME_SP_DAN_RANK_3_DAN: Final[int] = 9
    GAME_SP_DAN_RANK_4_DAN: Final[int] = 10
    GAME_SP_DAN_RANK_5_DAN: Final[int] = 11
    GAME_SP_DAN_RANK_6_DAN: Final[int] = 12
    GAME_SP_DAN_RANK_7_DAN: Final[int] = 13
    GAME_SP_DAN_RANK_8_DAN: Final[int] = 14
    GAME_SP_DAN_RANK_9_DAN: Final[int] = 15
    GAME_SP_DAN_RANK_10_DAN: Final[int] = 16
    GAME_SP_DAN_RANK_CHUDEN: Final[int] = 17
    GAME_SP_DAN_RANK_KAIDEN: Final[int] = 18

    GAME_DP_DAN_RANK_7_KYU: Final[int] = 0
    GAME_DP_DAN_RANK_6_KYU: Final[int] = 1
    GAME_DP_DAN_RANK_5_KYU: Final[int] = 2
    GAME_DP_DAN_RANK_4_KYU: Final[int] = 3
    GAME_DP_DAN_RANK_3_KYU: Final[int] = 4
    GAME_DP_DAN_RANK_2_KYU: Final[int] = 5
    GAME_DP_DAN_RANK_1_KYU: Final[int] = 6
    GAME_DP_DAN_RANK_1_DAN: Final[int] = 7
    GAME_DP_DAN_RANK_2_DAN: Final[int] = 8
    GAME_DP_DAN_RANK_3_DAN: Final[int] = 9
    GAME_DP_DAN_RANK_4_DAN: Final[int] = 10
    GAME_DP_DAN_RANK_5_DAN: Final[int] = 11
    GAME_DP_DAN_RANK_6_DAN: Final[int] = 12
    GAME_DP_DAN_RANK_7_DAN: Final[int] = 13
    GAME_DP_DAN_RANK_8_DAN: Final[int] = 14
    GAME_DP_DAN_RANK_9_DAN: Final[int] = 15
    GAME_DP_DAN_RANK_10_DAN: Final[int] = 16
    GAME_DP_DAN_RANK_CHUDEN: Final[int] = 17
    GAME_DP_DAN_RANK_KAIDEN: Final[int] = 18

    FAVORITE_LIST_LENGTH: Final[int] = 20

    GAME_CHART_TYPE_N7: Final[int] = 0
    GAME_CHART_TYPE_H7: Final[int] = 1
    GAME_CHART_TYPE_A7: Final[int] = 2
    GAME_CHART_TYPE_N14: Final[int] = 3
    GAME_CHART_TYPE_H14: Final[int] = 4
    GAME_CHART_TYPE_A14: Final[int] = 5
    GAME_CHART_TYPE_B7: Final[int] = 6

    requires_extended_regions: bool = True

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

    @classmethod
    def run_scheduled_work(
        cls, data: Data, config: Dict[str, Any]
    ) -> List[Tuple[str, Dict[str, Any]]]:
        """
        Insert dailies into the DB.
        """
        events = []
        if data.local.network.should_schedule(
            cls.game, cls.version, "daily_charts", "daily"
        ):
            # Generate a new list of three dailies.
            start_time, end_time = data.local.network.get_schedule_duration("daily")
            all_songs = list(
                set(
                    [
                        song.id
                        for song in data.local.music.get_all_songs(
                            cls.game, cls.version
                        )
                    ]
                )
            )
            if len(all_songs) >= 3:
                daily_songs = random.sample(all_songs, 3)
                data.local.game.put_time_sensitive_settings(
                    cls.game,
                    cls.version,
                    "dailies",
                    {
                        "start_time": start_time,
                        "end_time": end_time,
                        "music": daily_songs,
                    },
                )
                events.append(
                    (
                        "iidx_daily_charts",
                        {
                            "version": cls.version,
                            "music": daily_songs,
                        },
                    )
                )

                # Mark that we did some actual work here.
                data.local.network.mark_scheduled(
                    cls.game, cls.version, "daily_charts", "daily"
                )
        return events

    @classmethod
    def get_settings(cls) -> Dict[str, Any]:
        """
        Return all of our front-end modifiably settings.
        """
        return {
            "bools": [
                {
                    "name": "Global Shop Ranking",
                    "tip": "Return network-wide ranking instead of shop ranking on results screen.",
                    "category": "game_config",
                    "setting": "global_shop_ranking",
                },
                {
                    "name": "Events In Omnimix",
                    "tip": "Allow events to be enabled at all for Omnimix.",
                    "category": "game_config",
                    "setting": "omnimix_events_enabled",
                },
            ],
            "ints": [
                {
                    "name": "Event Phase",
                    "tip": "Event phase for all players.",
                    "category": "game_config",
                    "setting": "event_phase",
                    "values": {
                        0: "No Event",
                        1: "Gekisou! Cannon racer Continent 1",
                        2: "Gekisou! Cannon racer Continent 2",
                        3: "Gekisou! Cannon racer Continent 3",
                        4: "Gekisou! Cannon racer Continent 4",
                    },
                },
            ],
        }

    def db_to_game_status(self, db_status: int) -> int:
        return {
            self.CLEAR_STATUS_NO_PLAY: self.GAME_CLEAR_STATUS_NO_PLAY,
            self.CLEAR_STATUS_FAILED: self.GAME_CLEAR_STATUS_FAILED,
            self.CLEAR_STATUS_ASSIST_CLEAR: self.GAME_CLEAR_STATUS_ASSIST_CLEAR,
            self.CLEAR_STATUS_EASY_CLEAR: self.GAME_CLEAR_STATUS_EASY_CLEAR,
            self.CLEAR_STATUS_CLEAR: self.GAME_CLEAR_STATUS_CLEAR,
            self.CLEAR_STATUS_HARD_CLEAR: self.GAME_CLEAR_STATUS_HARD_CLEAR,
            self.CLEAR_STATUS_EX_HARD_CLEAR: self.GAME_CLEAR_STATUS_EX_HARD_CLEAR,
            self.CLEAR_STATUS_FULL_COMBO: self.GAME_CLEAR_STATUS_FULL_COMBO,
        }[db_status]

    def game_to_db_status(self, game_status: int) -> int:
        return {
            self.GAME_CLEAR_STATUS_NO_PLAY: self.CLEAR_STATUS_NO_PLAY,
            self.GAME_CLEAR_STATUS_FAILED: self.CLEAR_STATUS_FAILED,
            self.GAME_CLEAR_STATUS_ASSIST_CLEAR: self.CLEAR_STATUS_ASSIST_CLEAR,
            self.GAME_CLEAR_STATUS_EASY_CLEAR: self.CLEAR_STATUS_EASY_CLEAR,
            self.GAME_CLEAR_STATUS_CLEAR: self.CLEAR_STATUS_CLEAR,
            self.GAME_CLEAR_STATUS_HARD_CLEAR: self.CLEAR_STATUS_HARD_CLEAR,
            self.GAME_CLEAR_STATUS_EX_HARD_CLEAR: self.CLEAR_STATUS_EX_HARD_CLEAR,
            self.GAME_CLEAR_STATUS_FULL_COMBO: self.CLEAR_STATUS_FULL_COMBO,
        }[game_status]

    def db_to_game_rank(self, db_dan: int, cltype: int) -> int:
        # Special case for no DAN rank
        if db_dan == -1:
            return -1

        if cltype == self.GAME_CLTYPE_SINGLE:
            return {
                self.DAN_RANK_7_KYU: self.GAME_SP_DAN_RANK_7_KYU,
                self.DAN_RANK_6_KYU: self.GAME_SP_DAN_RANK_6_KYU,
                self.DAN_RANK_5_KYU: self.GAME_SP_DAN_RANK_5_KYU,
                self.DAN_RANK_4_KYU: self.GAME_SP_DAN_RANK_4_KYU,
                self.DAN_RANK_3_KYU: self.GAME_SP_DAN_RANK_3_KYU,
                self.DAN_RANK_2_KYU: self.GAME_SP_DAN_RANK_2_KYU,
                self.DAN_RANK_1_KYU: self.GAME_SP_DAN_RANK_1_KYU,
                self.DAN_RANK_1_DAN: self.GAME_SP_DAN_RANK_1_DAN,
                self.DAN_RANK_2_DAN: self.GAME_SP_DAN_RANK_2_DAN,
                self.DAN_RANK_3_DAN: self.GAME_SP_DAN_RANK_3_DAN,
                self.DAN_RANK_4_DAN: self.GAME_SP_DAN_RANK_4_DAN,
                self.DAN_RANK_5_DAN: self.GAME_SP_DAN_RANK_5_DAN,
                self.DAN_RANK_6_DAN: self.GAME_SP_DAN_RANK_6_DAN,
                self.DAN_RANK_7_DAN: self.GAME_SP_DAN_RANK_7_DAN,
                self.DAN_RANK_8_DAN: self.GAME_SP_DAN_RANK_8_DAN,
                self.DAN_RANK_9_DAN: self.GAME_SP_DAN_RANK_9_DAN,
                self.DAN_RANK_10_DAN: self.GAME_SP_DAN_RANK_10_DAN,
                self.DAN_RANK_CHUDEN: self.GAME_SP_DAN_RANK_CHUDEN,
                self.DAN_RANK_KAIDEN: self.GAME_SP_DAN_RANK_KAIDEN,
            }[db_dan]
        elif cltype == self.GAME_CLTYPE_DOUBLE:
            return {
                self.DAN_RANK_7_KYU: self.GAME_DP_DAN_RANK_7_KYU,
                self.DAN_RANK_6_KYU: self.GAME_DP_DAN_RANK_6_KYU,
                self.DAN_RANK_5_KYU: self.GAME_DP_DAN_RANK_5_KYU,
                self.DAN_RANK_4_KYU: self.GAME_DP_DAN_RANK_4_KYU,
                self.DAN_RANK_3_KYU: self.GAME_DP_DAN_RANK_3_KYU,
                self.DAN_RANK_2_KYU: self.GAME_DP_DAN_RANK_2_KYU,
                self.DAN_RANK_1_KYU: self.GAME_DP_DAN_RANK_1_KYU,
                self.DAN_RANK_1_DAN: self.GAME_DP_DAN_RANK_1_DAN,
                self.DAN_RANK_2_DAN: self.GAME_DP_DAN_RANK_2_DAN,
                self.DAN_RANK_3_DAN: self.GAME_DP_DAN_RANK_3_DAN,
                self.DAN_RANK_4_DAN: self.GAME_DP_DAN_RANK_4_DAN,
                self.DAN_RANK_5_DAN: self.GAME_DP_DAN_RANK_5_DAN,
                self.DAN_RANK_6_DAN: self.GAME_DP_DAN_RANK_6_DAN,
                self.DAN_RANK_7_DAN: self.GAME_DP_DAN_RANK_7_DAN,
                self.DAN_RANK_8_DAN: self.GAME_DP_DAN_RANK_8_DAN,
                self.DAN_RANK_9_DAN: self.GAME_DP_DAN_RANK_9_DAN,
                self.DAN_RANK_10_DAN: self.GAME_DP_DAN_RANK_10_DAN,
                self.DAN_RANK_CHUDEN: self.GAME_DP_DAN_RANK_CHUDEN,
                self.DAN_RANK_KAIDEN: self.GAME_DP_DAN_RANK_KAIDEN,
            }[db_dan]
        else:
            raise Exception("Invalid cltype!")

    def game_to_db_rank(self, game_dan: int, cltype: int) -> int:
        # Special case for no DAN rank
        if game_dan == -1:
            return -1

        if cltype == self.GAME_CLTYPE_SINGLE:
            return {
                self.GAME_SP_DAN_RANK_7_KYU: self.DAN_RANK_7_KYU,
                self.GAME_SP_DAN_RANK_6_KYU: self.DAN_RANK_6_KYU,
                self.GAME_SP_DAN_RANK_5_KYU: self.DAN_RANK_5_KYU,
                self.GAME_SP_DAN_RANK_4_KYU: self.DAN_RANK_4_KYU,
                self.GAME_SP_DAN_RANK_3_KYU: self.DAN_RANK_3_KYU,
                self.GAME_SP_DAN_RANK_2_KYU: self.DAN_RANK_2_KYU,
                self.GAME_SP_DAN_RANK_1_KYU: self.DAN_RANK_1_KYU,
                self.GAME_SP_DAN_RANK_1_DAN: self.DAN_RANK_1_DAN,
                self.GAME_SP_DAN_RANK_2_DAN: self.DAN_RANK_2_DAN,
                self.GAME_SP_DAN_RANK_3_DAN: self.DAN_RANK_3_DAN,
                self.GAME_SP_DAN_RANK_4_DAN: self.DAN_RANK_4_DAN,
                self.GAME_SP_DAN_RANK_5_DAN: self.DAN_RANK_5_DAN,
                self.GAME_SP_DAN_RANK_6_DAN: self.DAN_RANK_6_DAN,
                self.GAME_SP_DAN_RANK_7_DAN: self.DAN_RANK_7_DAN,
                self.GAME_SP_DAN_RANK_8_DAN: self.DAN_RANK_8_DAN,
                self.GAME_SP_DAN_RANK_9_DAN: self.DAN_RANK_9_DAN,
                self.GAME_SP_DAN_RANK_10_DAN: self.DAN_RANK_10_DAN,
                self.GAME_SP_DAN_RANK_CHUDEN: self.DAN_RANK_CHUDEN,
                self.GAME_SP_DAN_RANK_KAIDEN: self.DAN_RANK_KAIDEN,
            }[game_dan]
        elif cltype == self.GAME_CLTYPE_DOUBLE:
            return {
                self.GAME_DP_DAN_RANK_7_KYU: self.DAN_RANK_7_KYU,
                self.GAME_DP_DAN_RANK_6_KYU: self.DAN_RANK_6_KYU,
                self.GAME_DP_DAN_RANK_5_KYU: self.DAN_RANK_5_KYU,
                self.GAME_DP_DAN_RANK_4_KYU: self.DAN_RANK_4_KYU,
                self.GAME_DP_DAN_RANK_3_KYU: self.DAN_RANK_3_KYU,
                self.GAME_DP_DAN_RANK_2_KYU: self.DAN_RANK_2_KYU,
                self.GAME_DP_DAN_RANK_1_KYU: self.DAN_RANK_1_KYU,
                self.GAME_DP_DAN_RANK_1_DAN: self.DAN_RANK_1_DAN,
                self.GAME_DP_DAN_RANK_2_DAN: self.DAN_RANK_2_DAN,
                self.GAME_DP_DAN_RANK_3_DAN: self.DAN_RANK_3_DAN,
                self.GAME_DP_DAN_RANK_4_DAN: self.DAN_RANK_4_DAN,
                self.GAME_DP_DAN_RANK_5_DAN: self.DAN_RANK_5_DAN,
                self.GAME_DP_DAN_RANK_6_DAN: self.DAN_RANK_6_DAN,
                self.GAME_DP_DAN_RANK_7_DAN: self.DAN_RANK_7_DAN,
                self.GAME_DP_DAN_RANK_8_DAN: self.DAN_RANK_8_DAN,
                self.GAME_DP_DAN_RANK_9_DAN: self.DAN_RANK_9_DAN,
                self.GAME_DP_DAN_RANK_10_DAN: self.DAN_RANK_10_DAN,
                self.GAME_DP_DAN_RANK_CHUDEN: self.DAN_RANK_CHUDEN,
                self.GAME_DP_DAN_RANK_KAIDEN: self.DAN_RANK_KAIDEN,
            }[game_dan]
        else:
            raise Exception("Invalid cltype!")

    def game_to_db_chart(self, db_chart: int) -> int:
        return {
            self.GAME_CHART_TYPE_B7: self.CHART_TYPE_B7,
            self.GAME_CHART_TYPE_N7: self.CHART_TYPE_N7,
            self.GAME_CHART_TYPE_H7: self.CHART_TYPE_H7,
            self.GAME_CHART_TYPE_A7: self.CHART_TYPE_A7,
            self.GAME_CHART_TYPE_N14: self.CHART_TYPE_N14,
            self.GAME_CHART_TYPE_H14: self.CHART_TYPE_H14,
            self.GAME_CHART_TYPE_A14: self.CHART_TYPE_A14,
        }[db_chart]

    def handle_IIDX25shop_getname_request(self, request: Node) -> Node:
        machine = self.data.local.machine.get_machine(self.config.machine.pcbid)
        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("IIDX25shop")
        root.set_attribute("opname", machine_name)
        root.set_attribute("pid", str(self.get_machine_region()))
        root.set_attribute("cls_opt", "1" if close else "0")
        root.set_attribute("hr", str(hour))
        root.set_attribute("mi", str(minute))
        return root

    def handle_IIDX25shop_savename_request(self, request: Node) -> Node:
        self.update_machine_name(request.attribute("opname"))

        shop_close = intish(request.attribute("cls_opt")) or 0
        minutes = intish(request.attribute("mnt")) or 0
        hours = intish(request.attribute("hr")) or 0

        self.update_machine_data(
            {
                "close": shop_close != 0,
                "minutes": minutes,
                "hours": hours,
            }
        )

        return Node.void("IIDX25shop")

    def handle_IIDX25shop_sentinfo_request(self, request: Node) -> Node:
        return Node.void("IIDX25shop")

    def handle_IIDX25shop_sendescapepackageinfo_request(self, request: Node) -> Node:
        root = Node.void("IIDX25shop")
        root.set_attribute("expire", str((Time.now() + 86400 * 365) * 1000))
        return root

    def handle_IIDX25shop_getconvention_request(self, request: Node) -> Node:
        root = Node.void("IIDX25shop")
        machine = self.data.local.machine.get_machine(self.config.machine.pcbid)
        if machine.arcade is not None:
            course = self.data.local.machine.get_settings(
                machine.arcade, self.game, self.music_version, "shop_course"
            )
        else:
            course = None

        if course is None:
            course = ValidatedDict()

        root.set_attribute("music_0", str(course.get_int("music_0", 20032)))
        root.set_attribute("music_1", str(course.get_int("music_1", 20009)))
        root.set_attribute("music_2", str(course.get_int("music_2", 20015)))
        root.set_attribute("music_3", str(course.get_int("music_3", 20064)))
        root.add_child(Node.bool("valid", course.get_bool("valid")))
        return root

    def handle_IIDX25shop_setconvention_request(self, request: Node) -> Node:
        machine = self.data.local.machine.get_machine(self.config.machine.pcbid)
        if machine.arcade is not None:
            course = ValidatedDict()
            course.replace_int("music_0", request.child_value("music_0"))
            course.replace_int("music_1", request.child_value("music_1"))
            course.replace_int("music_2", request.child_value("music_2"))
            course.replace_int("music_3", request.child_value("music_3"))
            course.replace_bool("valid", request.child_value("valid"))
            self.data.local.machine.put_settings(
                machine.arcade, self.game, self.music_version, "shop_course", course
            )

        return Node.void("IIDX25shop")

    def handle_IIDX25ranking_getranker_request(self, request: Node) -> Node:
        root = Node.void("IIDX25ranking")
        chart = self.game_to_db_chart(int(request.attribute("clid")))
        if chart not in [
            self.CHART_TYPE_N7,
            self.CHART_TYPE_H7,
            self.CHART_TYPE_A7,
            self.CHART_TYPE_N14,
            self.CHART_TYPE_H14,
            self.CHART_TYPE_A14,
        ]:
            # Chart type 6 is presumably beginner mode, but it crashes the game
            return root

        machine = self.data.local.machine.get_machine(self.config.machine.pcbid)
        if machine.arcade is not None:
            course = self.data.local.machine.get_settings(
                machine.arcade, self.game, self.music_version, "shop_course"
            )
        else:
            course = None

        if course is None:
            course = ValidatedDict()

        if not course.get_bool("valid"):
            # Shop course not enabled or not present
            return root

        convention = Node.void("convention")
        root.add_child(convention)
        convention.set_attribute("clid", str(chart))
        convention.set_attribute("update_date", str(Time.now() * 1000))

        # Grab all scores for each of the four songs, filter all scores not achieved
        # on this machine and then return the top 20 scores (adding all 4 songs).
        songids = [
            course.get_int("music_0"),
            course.get_int("music_1"),
            course.get_int("music_2"),
            course.get_int("music_3"),
        ]

        totalscores: Dict[UserID, int] = {}
        profiles: Dict[UserID, Profile] = {}
        for songid in songids:
            scores = self.data.local.music.get_all_scores(
                self.game,
                self.music_version,
                songid=songid,
                songchart=chart,
            )

            for score in scores:
                # Exclude scores not achieved here
                if score[1].location != machine.id:
                    continue
                if score[0] not in totalscores:
                    totalscores[score[0]] = 0
                    profile = self.get_any_profile(score[0])
                    if profile is None:
                        profile = Profile(self.game, self.version, "", 0)
                    profiles[score[0]] = profile

                totalscores[score[0]] += score[1].points

        topscores = sorted(
            [(totalscores[userid], profiles[userid]) for userid in totalscores],
            key=lambda tup: tup[0],
            reverse=True,
        )[:20]

        rank = 0
        for topscore in topscores:
            rank = rank + 1

            detail = Node.void("detail")
            convention.add_child(detail)
            detail.set_attribute("name", topscore[1].get_str("name"))
            detail.set_attribute("rank", str(rank))
            detail.set_attribute("score", str(topscore[0]))
            detail.set_attribute("pid", str(topscore[1].get_int("pid")))

            qpro = topscore[1].get_dict("qpro")
            detail.set_attribute("head", str(qpro.get_int("head")))
            detail.set_attribute("hair", str(qpro.get_int("hair")))
            detail.set_attribute("face", str(qpro.get_int("face")))
            detail.set_attribute("body", str(qpro.get_int("body")))
            detail.set_attribute("hand", str(qpro.get_int("hand")))

        return root

    def handle_IIDX25ranking_entry_request(self, request: Node) -> Node:
        extid = int(request.attribute("iidxid"))
        courseid = int(request.attribute("coid"))
        chart = self.game_to_db_chart(int(request.attribute("clid")))
        course_type = int(request.attribute("regist_type"))
        clear_status = self.game_to_db_status(int(request.attribute("clr")))
        pgreats = int(request.attribute("pgnum"))
        greats = int(request.attribute("gnum"))

        if course_type == 0:
            index = self.COURSE_TYPE_INTERNET_RANKING
        elif course_type == 1:
            index = self.COURSE_TYPE_SECRET
        else:
            raise Exception("Unknown registration type for course entry!")

        userid = self.data.remote.user.from_extid(self.game, self.version, extid)
        if userid is not None:
            # Update achievement to track course statistics
            self.update_course(
                userid,
                index,
                courseid,
                chart,
                clear_status,
                pgreats,
                greats,
            )

        # We should return the user's position, but its not displayed anywhere
        # so fuck it.
        root = Node.void("IIDX25ranking")
        root.set_attribute("anum", "1")
        root.set_attribute("jun", "1")
        return root

    def handle_IIDX25ranking_classicentry_request(self, request: Node) -> Node:
        extid = int(request.attribute("iidx_id"))
        courseid = int(request.attribute("course_id"))
        coursestyle = int(request.attribute("play_style"))
        clear_status = self.game_to_db_status(int(request.attribute("clear_flg")))
        pgreats = int(request.attribute("pgnum"))
        greats = int(request.attribute("gnum"))

        userid = self.data.remote.user.from_extid(self.game, self.version, extid)
        if userid is not None:
            # Update achievement to track course statistics
            self.update_course(
                userid,
                self.COURSE_TYPE_CLASSIC,
                courseid,
                coursestyle,
                clear_status,
                pgreats,
                greats,
            )

        return Node.void("IIDX25ranking")

    def handle_IIDX25music_crate_request(self, request: Node) -> Node:
        root = Node.void("IIDX25music")
        attempts = self.get_clear_rates()

        all_songs = list(
            set(
                [
                    song.id
                    for song in self.data.local.music.get_all_songs(
                        self.game, self.music_version
                    )
                ]
            )
        )
        for song in all_songs:
            clears = []
            fcs = []

            for chart in [0, 1, 2, 3, 4, 5]:
                placed = False
                if song in attempts and chart in attempts[song]:
                    values = attempts[song][chart]
                    if values["total"] > 0:
                        clears.append(int((1000 * values["clears"]) / values["total"]))
                        fcs.append(int((1000 * values["fcs"]) / values["total"]))
                        placed = True
                if not placed:
                    clears.append(1001)
                    fcs.append(1001)

            clearnode = Node.s32_array("c", clears + fcs)
            clearnode.set_attribute("mid", str(song))
            root.add_child(clearnode)

        return root

    def handle_IIDX25music_getrank_request(self, request: Node) -> Node:
        cltype = int(request.attribute("cltype"))

        root = Node.void("IIDX25music")
        style = Node.void("style")
        root.add_child(style)
        style.set_attribute("type", str(cltype))

        for rivalid in [-1, 0, 1, 2, 3, 4]:
            if rivalid == -1:
                attr = "iidxid"
            else:
                attr = f"iidxid{rivalid}"

            try:
                extid = int(request.attribute(attr))
            except Exception:
                # Invalid extid
                continue
            userid = self.data.remote.user.from_extid(self.game, self.version, extid)
            if userid is not None:
                scores = self.data.remote.music.get_scores(
                    self.game, self.music_version, userid
                )

                # Grab score data for user/rival
                scoredata = self.make_score_struct(
                    scores,
                    self.CLEAR_TYPE_SINGLE
                    if cltype == self.GAME_CLTYPE_SINGLE
                    else self.CLEAR_TYPE_DOUBLE,
                    rivalid,
                )
                for s in scoredata:
                    root.add_child(Node.s16_array("m", s))

                # Grab most played for user/rival
                most_played = [
                    play[0]
                    for play in self.data.local.music.get_most_played(
                        self.game, self.music_version, userid, 20
                    )
                ]
                if len(most_played) < 20:
                    most_played.extend([0] * (20 - len(most_played)))
                best = Node.u16_array("best", most_played)
                best.set_attribute("rno", str(rivalid))
                root.add_child(best)

                if rivalid == -1:
                    # Grab beginner statuses for user only
                    beginnerdata = self.make_beginner_struct(scores)
                    for b in beginnerdata:
                        root.add_child(Node.u16_array("b", b))

        return root

    def handle_IIDX25music_appoint_request(self, request: Node) -> Node:
        musicid = int(request.attribute("mid"))
        chart = self.game_to_db_chart(int(request.attribute("clid")))
        ghost_type = int(request.attribute("ctype"))
        extid = int(request.attribute("iidxid"))
        userid = self.data.remote.user.from_extid(self.game, self.version, extid)

        root = Node.void("IIDX25music")

        if userid is not None:
            # Try to look up previous ghost for user
            my_score = self.data.remote.music.get_score(
                self.game, self.music_version, userid, musicid, chart
            )
            if my_score is not None:
                mydata = Node.binary("mydata", my_score.data.get_bytes("ghost"))
                mydata.set_attribute("score", str(my_score.points))
                root.add_child(mydata)

            ghost_score = self.get_ghost(
                {
                    self.GAME_GHOST_TYPE_RIVAL: self.GHOST_TYPE_RIVAL,
                    self.GAME_GHOST_TYPE_GLOBAL_TOP: self.GHOST_TYPE_GLOBAL_TOP,
                    self.GAME_GHOST_TYPE_GLOBAL_AVERAGE: self.GHOST_TYPE_GLOBAL_AVERAGE,
                    self.GAME_GHOST_TYPE_LOCAL_TOP: self.GHOST_TYPE_LOCAL_TOP,
                    self.GAME_GHOST_TYPE_LOCAL_AVERAGE: self.GHOST_TYPE_LOCAL_AVERAGE,
                    self.GAME_GHOST_TYPE_DAN_TOP: self.GHOST_TYPE_DAN_TOP,
                    self.GAME_GHOST_TYPE_DAN_AVERAGE: self.GHOST_TYPE_DAN_AVERAGE,
                    self.GAME_GHOST_TYPE_RIVAL_TOP: self.GHOST_TYPE_RIVAL_TOP,
                    self.GAME_GHOST_TYPE_RIVAL_AVERAGE: self.GHOST_TYPE_RIVAL_AVERAGE,
                }.get(ghost_type, self.GHOST_TYPE_NONE),
                request.attribute("subtype"),
                self.GAME_GHOST_LENGTH,
                musicid,
                chart,
                userid,
            )

            # Add ghost score if we support it
            if ghost_score is not None:
                sdata = Node.binary("sdata", ghost_score["ghost"])
                sdata.set_attribute("score", str(ghost_score["score"]))
                if "name" in ghost_score:
                    sdata.set_attribute("name", ghost_score["name"])
                if "pid" in ghost_score:
                    sdata.set_attribute("pid", str(ghost_score["pid"]))
                if "extid" in ghost_score:
                    sdata.set_attribute("riidxid", str(ghost_score["extid"]))
                root.add_child(sdata)

        return root

    def handle_IIDX25music_breg_request(self, request: Node) -> Node:
        extid = int(request.attribute("iidxid"))
        musicid = int(request.attribute("mid"))
        userid = self.data.remote.user.from_extid(self.game, self.version, extid)

        if userid is not None:
            clear_status = self.game_to_db_status(int(request.attribute("cflg")))
            pgreats = int(request.attribute("pgnum"))
            greats = int(request.attribute("gnum"))

        self.update_score(
            userid,
            musicid,
            self.CHART_TYPE_B7,
            clear_status,
            pgreats,
            greats,
            -1,
            b"",
            None,
        )

        # Return nothing.
        return Node.void("IIDX25music")

    def handle_IIDX25music_reg_request(self, request: Node) -> Node:
        extid = int(request.attribute("iidxid"))
        musicid = int(request.attribute("mid"))
        chart = self.game_to_db_chart(int(request.attribute("clid")))
        userid = self.data.remote.user.from_extid(self.game, self.version, extid)

        # See if we need to report global or shop scores
        if self.machine_joined_arcade():
            game_config = self.get_game_config()
            global_scores = game_config.get_bool("global_shop_ranking")
            machine = self.data.local.machine.get_machine(self.config.machine.pcbid)
        else:
            # If we aren't in an arcade, we can only show global scores
            global_scores = True
            machine = None

        # First, determine our current ranking before saving the new score
        all_scores = sorted(
            self.data.remote.music.get_all_scores(
                game=self.game,
                version=self.music_version,
                songid=musicid,
                songchart=chart,
            ),
            key=lambda s: (s[1].points, s[1].timestamp),
            reverse=True,
        )
        all_players = {
            uid: prof
            for (uid, prof) in self.get_any_profiles([s[0] for s in all_scores])
        }

        shop_id = ID.parse_machine_id(request.attribute("location_id"))
        if not global_scores:
            all_scores = [
                score
                for score in all_scores
                if (score[0] == userid or score[1].location == shop_id)
            ]

        # Find our actual index
        oldindex = None
        for i in range(len(all_scores)):
            if all_scores[i][0] == userid:
                oldindex = i
                break

        if userid is not None:
            clear_status = self.game_to_db_status(int(request.attribute("cflg")))
            pgreats = int(request.attribute("pgnum"))
            greats = int(request.attribute("gnum"))
            miss_count = int(request.attribute("mnum"))
            ghost = request.child_value("ghost")
            shopid = ID.parse_machine_id(request.attribute("convid"))

            self.update_score(
                userid,
                musicid,
                chart,
                clear_status,
                pgreats,
                greats,
                miss_count,
                ghost,
                shopid,
            )

        # Calculate and return statistics about this song
        root = Node.void("IIDX25music")
        root.set_attribute("clid", request.attribute("clid"))
        root.set_attribute("mid", request.attribute("mid"))

        attempts = self.get_clear_rates(musicid, chart)
        count = attempts[musicid][chart]["total"]
        clear = attempts[musicid][chart]["clears"]
        full_combo = attempts[musicid][chart]["fcs"]

        if count > 0:
            root.set_attribute("crate", str(int((1000 * clear) / count)))
            root.set_attribute("frate", str(int((1000 * full_combo) / count)))
        else:
            root.set_attribute("crate", "0")
            root.set_attribute("frate", "0")
        root.set_attribute("rankside", "0")

        if userid is not None:
            # Shop ranking
            shopdata = Node.void("shopdata")
            root.add_child(shopdata)
            shopdata.set_attribute(
                "rank", "-1" if oldindex is None else str(oldindex + 1)
            )

            # Grab the rank of some other players on this song
            ranklist = Node.void("ranklist")
            root.add_child(ranklist)

            all_scores = sorted(
                self.data.remote.music.get_all_scores(
                    game=self.game,
                    version=self.music_version,
                    songid=musicid,
                    songchart=chart,
                ),
                key=lambda s: (s[1].points, s[1].timestamp),
                reverse=True,
            )
            missing_players = [uid for (uid, _) in all_scores if uid not in all_players]
            for uid, prof in self.get_any_profiles(missing_players):
                all_players[uid] = prof

            if not global_scores:
                all_scores = [
                    score
                    for score in all_scores
                    if (score[0] == userid or score[1].location == shop_id)
                ]

            # Find our actual index
            ourindex = None
            for i in range(len(all_scores)):
                if all_scores[i][0] == userid:
                    ourindex = i
                    break
            if ourindex is None:
                raise Exception("Cannot find our own score after saving to DB!")
            start = ourindex - 4
            end = ourindex + 4
            if start < 0:
                start = 0
            if end >= len(all_scores):
                end = len(all_scores) - 1
            relevant_scores = all_scores[start : (end + 1)]

            record_num = start + 1
            for score in relevant_scores:
                profile = all_players[score[0]]

                data = Node.void("data")
                ranklist.add_child(data)
                data.set_attribute("iidx_id", str(profile.extid))
                data.set_attribute("name", profile.get_str("name"))

                machine_name = ""
                machine = self.get_machine_by_id(shop_id)
                if machine is not None:
                    machine_name = machine.name
                data.set_attribute("opname", machine_name)
                data.set_attribute("rnum", str(record_num))
                data.set_attribute("score", str(score[1].points))
                data.set_attribute(
                    "clflg",
                    str(self.db_to_game_status(score[1].data.get_int("clear_status"))),
                )
                data.set_attribute("pid", str(profile.get_int("pid")))
                data.set_attribute("myFlg", "1" if score[0] == userid else "0")
                data.set_attribute("update", "0")

                data.set_attribute(
                    "sgrade",
                    str(
                        self.db_to_game_rank(
                            profile.get_int(self.DAN_RANKING_SINGLE, -1),
                            self.GAME_CLTYPE_SINGLE,
                        ),
                    ),
                )
                data.set_attribute(
                    "dgrade",
                    str(
                        self.db_to_game_rank(
                            profile.get_int(self.DAN_RANKING_DOUBLE, -1),
                            self.GAME_CLTYPE_DOUBLE,
                        ),
                    ),
                )

                qpro = profile.get_dict("qpro")
                data.set_attribute("head", str(qpro.get_int("head")))
                data.set_attribute("hair", str(qpro.get_int("hair")))
                data.set_attribute("face", str(qpro.get_int("face")))
                data.set_attribute("body", str(qpro.get_int("body")))
                data.set_attribute("hand", str(qpro.get_int("hand")))

                record_num = record_num + 1

        return root

    def handle_IIDX25music_play_request(self, request: Node) -> Node:
        musicid = int(request.attribute("mid"))
        chart = self.game_to_db_chart(int(request.attribute("clid")))
        clear_status = self.game_to_db_status(int(request.attribute("cflg")))

        self.update_score(
            None,  # No userid since its anonymous
            musicid,
            chart,
            clear_status,
            0,  # No ex score
            0,  # No ex score
            0,  # No miss count
            None,  # No ghost
            None,  # No shop for this user
        )

        # Calculate and return statistics about this song
        root = Node.void("IIDX25music")
        root.set_attribute("clid", request.attribute("clid"))
        root.set_attribute("mid", request.attribute("mid"))

        attempts = self.get_clear_rates(musicid, chart)
        count = attempts[musicid][chart]["total"]
        clear = attempts[musicid][chart]["clears"]
        full_combo = attempts[musicid][chart]["fcs"]

        if count > 0:
            root.set_attribute("crate", str(int((1000 * clear) / count)))
            root.set_attribute("frate", str(int((1000 * full_combo) / count)))
        else:
            root.set_attribute("crate", "0")
            root.set_attribute("frate", "0")

        return root

    # Bare minimum response to say we handled the request
    def handle_IIDX25music_beginnerplay_request(self, request: Node) -> Node:
        return Node.void("IIDX25music")

    def handle_IIDX25music_arenaCPU_request(self, request: Node) -> Node:
        root = Node.void("IIDX25music")
        music_list = [0, 0, 0, 0]
        cpu_list = [0, 0, 0, 0]
        grade_to_percentage_map = {
            self.GAME_SP_DAN_RANK_1_KYU: 50,
            self.GAME_SP_DAN_RANK_1_DAN: 55,
            self.GAME_SP_DAN_RANK_2_DAN: 60,
            self.GAME_SP_DAN_RANK_3_DAN: 60,
            self.GAME_SP_DAN_RANK_4_DAN: 65,
            self.GAME_SP_DAN_RANK_5_DAN: 65,
            self.GAME_SP_DAN_RANK_6_DAN: 70,
            self.GAME_SP_DAN_RANK_7_DAN: 70,
            self.GAME_SP_DAN_RANK_8_DAN: 75,
            self.GAME_SP_DAN_RANK_9_DAN: 75,
            self.GAME_SP_DAN_RANK_10_DAN: 80,
            self.GAME_SP_DAN_RANK_CHUDEN: 80,
            self.GAME_SP_DAN_RANK_KAIDEN: 80,
        }
        for item in request.children:
            if item.name == "music_list":
                music_list[int(item.child_value("index"))] = int(
                    item.child_value("total_notes")
                )
            if item.name == "cpu_list":
                cpu_list[int(item.child_value("index"))] = int(
                    item.child_value("grade_id")
                )
        for index in range(4):
            cpu_score_list = Node.void("cpu_score_list")
            cpu_score_list.add_child(Node.s32("index", index))
            root.add_child(cpu_score_list)
            for i in range(4):
                score_list = Node.void("score_list")
                cpu_score_list.add_child(score_list)
                percentage = grade_to_percentage_map.get(cpu_list[index], 0)
                notes = music_list[i]
                score = (notes * 2 * percentage) // 100
                ghost_section = score // 64
                ghost = [ghost_section] * 64
                ghost_total = ghost_section * 64
                ghost_lost = score - ghost_total
                ghost[0] = ghost[0] + ghost_lost
                score_list.add_child(Node.s32("score", score))
                score_list.add_child(Node.bool("enable_score", True))
                score_list.add_child(Node.u8_array("ghost", ghost))
                score_list.add_child(Node.bool("enable_ghost", True))
        return root

    def handle_IIDX25grade_raised_request(self, request: Node) -> Node:
        extid = int(request.attribute("iidxid"))
        cltype = int(request.attribute("gtype"))
        rank = self.game_to_db_rank(int(request.attribute("gid")), cltype)

        userid = self.data.remote.user.from_extid(self.game, self.version, extid)
        if userid is not None:
            percent = int(request.attribute("achi"))
            stages_cleared = int(request.attribute("cstage"))
            cleared = stages_cleared == self.DAN_STAGES

            if cltype == self.GAME_CLTYPE_SINGLE:
                index = self.DAN_RANKING_SINGLE
            else:
                index = self.DAN_RANKING_DOUBLE

            self.update_rank(
                userid,
                index,
                rank,
                percent,
                cleared,
                stages_cleared,
            )

        # Figure out number of players that played this ranking
        all_achievements = self.data.local.user.get_all_achievements(
            self.game, self.version, achievementid=rank, achievementtype=index
        )
        root = Node.void("IIDX25grade")
        root.set_attribute("pnum", str(len(all_achievements)))
        return root

    def handle_IIDX25pc_common_request(self, request: Node) -> Node:
        root = Node.void("IIDX25pc")
        root.set_attribute("expire", "600")

        ir = Node.void("ir")
        root.add_child(ir)
        ir.set_attribute("beat", "2")

        vip_black_pass = Node.void("vip_pass_black")
        root.add_child(vip_black_pass)

        newsong_another = Node.void("newsong_another")
        root.add_child(newsong_another)
        newsong_another.set_attribute("open", "1")

        deller_bonus = Node.void("deller_bonus")
        root.add_child(deller_bonus)
        deller_bonus.set_attribute("open", "1")

        common_evnet = Node.void("common_evnet")  # Yes, this is misspelled in the game
        root.add_child(common_evnet)
        common_evnet.set_attribute("flg", "0")

        # See if we configured event overrides
        if self.machine_joined_arcade():
            game_config = self.get_game_config()
            event_phase = game_config.get_int("event_phase")
            omni_events = game_config.get_bool("omnimix_events_enabled")
        else:
            # If we aren't in an arcade, we turn off events
            event_phase = 0
            omni_events = False

        if event_phase == 0 or (self.omnimix and (not omni_events)):
            event1 = 0
            boss_phase = 0
        elif event_phase in [1, 2, 3, 4]:
            boss_phase = 1
            event1 = event_phase - 1

        boss = Node.void("boss")
        root.add_child(boss)
        boss.set_attribute("phase", str(boss_phase))

        event1_phase = Node.void("event1_phase")
        root.add_child(event1_phase)
        event1_phase.set_attribute("phase", str(event1))

        extra_boss_event = Node.void(
            "extra_boss_event"
        )  # Always enable IIDX AIR RACE 5
        root.add_child(extra_boss_event)
        extra_boss_event.set_attribute("phase", "4")

        # Course definitions
        courses: List[Dict[str, Any]] = [
            {
                "name": "EUROBEAT",
                "id": 1,
                "songs": [
                    17040,
                    8006,
                    10033,
                    25001,
                ],
            },
            {
                "name": "WEATHER",
                "id": 2,
                "open_music_id": 15104,
                "songs": [
                    17023,
                    9030,
                    15004,
                    10024,
                ],
            },
            {
                "name": "FEAT. KANAE ASABA",
                "id": 3,
                "open_music_id": 24101,
                "songs": [
                    25056,
                    23033,
                    24011,
                    21034,
                ],
            },
            {
                "name": "BLOOM",
                "id": 4,
                "songs": [
                    15054,
                    20053,
                    20004,
                    23083,
                ],
            },
            {
                "name": "VACUUM",
                "id": 5,
                "songs": [
                    19070,
                    23021,
                    17002,
                    18071,
                ],
            },
            {
                "name": "PRINCESS",
                "id": 6,
                "open_music_id": 12100,
                "songs": [
                    25024,
                    20021,
                    19046,
                    12002,
                ],
            },
            {
                "name": "TECHNO",
                "id": 7,
                "open_music_id": 19100,
                "songs": [
                    25026,
                    19063,
                    17061,
                    23085,
                ],
            },
            {
                "name": "POP",
                "id": 8,
                "open_music_id": 15103,
                "songs": [
                    15061,
                    20099,
                    20101,
                    22093,
                ],
            },
            {
                "name": "CARDINAL",
                "id": 9,
                "open_music_id": 13101,
                "songs": [
                    13038,
                    13026,
                    13000,
                    13010,
                ],
            },
            {
                "name": "O2K",
                "id": 10,
                "songs": [
                    21059,
                    19002,
                    22054,
                    16020,
                ],
            },
        ]

        # Secret course definitions
        secret_courses: List[Dict[str, Any]] = [
            {
                "name": "EMOTIONAL",
                "id": 1,
                "songs": [
                    21009,
                    25006,
                    17065,
                    25066,
                ],
            },
            {
                "name": "RYU",
                "id": 2,
                "songs": [
                    23082,
                    21007,
                    23037,
                    25067,
                ],
            },
        ]

        # For some reason, omnimix crashes on course mode, so don't enable it
        if not self.omnimix:
            internet_ranking = Node.void("internet_ranking")
            root.add_child(internet_ranking)

            used_ids: List[int] = []
            for c in courses:
                if c["id"] in used_ids:
                    raise Exception("Cannot have multiple courses with the same ID!")
                elif c["id"] < 0 or c["id"] >= 20:
                    raise Exception("Course ID is out of bounds!")
                else:
                    used_ids.append(c["id"])

                course = Node.void("course")
                internet_ranking.add_child(course)
                course.set_attribute("course_id", str(c["id"]))
                course.set_attribute("name", c["name"])
                course.set_attribute("mid0", str(c["songs"][0]))
                course.set_attribute("mid1", str(c["songs"][1]))
                course.set_attribute("mid2", str(c["songs"][2]))
                course.set_attribute("mid3", str(c["songs"][3]))
                course.set_attribute("open_music_id", str(c.get("open_music_id", 0)))
                course.set_attribute("opflg", "1")

            secret_ex_course = Node.void("secret_ex_course")
            root.add_child(secret_ex_course)

            used_secret_ids: List[int] = []
            for c in secret_courses:
                if c["id"] in used_secret_ids:
                    raise Exception(
                        "Cannot have multiple secret courses with the same ID!"
                    )
                elif c["id"] < 0 or c["id"] >= 20:
                    raise Exception("Secret course ID is out of bounds!")
                else:
                    used_secret_ids.append(c["id"])

                course = Node.void("course")
                secret_ex_course.add_child(course)
                course.set_attribute("course_id", str(c["id"]))
                course.set_attribute("name", c["name"])
                course.set_attribute("mid0", str(c["songs"][0]))
                course.set_attribute("mid1", str(c["songs"][1]))
                course.set_attribute("mid2", str(c["songs"][2]))
                course.set_attribute("mid3", str(c["songs"][3]))

            expert = Node.void("expert")
            root.add_child(expert)
            expert.set_attribute("phase", "1")

            expert_random_select = Node.void("expert_random_select")
            root.add_child(expert_random_select)
            expert_random_select.set_attribute("phase", "1")

            expert_full = Node.void("expert_secret_full_open")
            root.add_child(expert_full)

        return root

    def handle_IIDX25pc_delete_request(self, request: Node) -> Node:
        return Node.void("IIDX25pc")

    def handle_IIDX25pc_playstart_request(self, request: Node) -> Node:
        return Node.void("IIDX25pc")

    def handle_IIDX25pc_playend_request(self, request: Node) -> Node:
        return Node.void("IIDX25pc")

    def handle_IIDX25pc_visit_request(self, request: Node) -> Node:
        root = Node.void("IIDX25pc")
        root.set_attribute("anum", "0")
        root.set_attribute("snum", "0")
        root.set_attribute("pnum", "0")
        root.set_attribute("aflg", "0")
        root.set_attribute("sflg", "0")
        root.set_attribute("pflg", "0")
        return root

    def handle_IIDX25pc_shopregister_request(self, request: Node) -> Node:
        root = Node.void("IIDX25pc")
        return root

    def handle_IIDX25pc_oldget_request(self, request: Node) -> Node:
        refid = request.attribute("rid")
        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
        if userid is not None:
            oldversion = self.previous_version()
            profile = oldversion.get_profile(userid)
        else:
            profile = None

        root = Node.void("IIDX25pc")
        root.set_attribute("status", "1" if profile is None else "0")
        return root

    def handle_IIDX25pc_getname_request(self, request: Node) -> Node:
        refid = request.attribute("rid")
        userid = self.data.remote.user.from_refid(self.game, self.version, refid)
        if userid is not None:
            oldversion = self.previous_version()
            profile = oldversion.get_profile(userid)
        else:
            profile = None
        if profile is None:
            raise Exception(
                "Should not get here if we have no profile, we should "
                + "have returned '1' in the 'oldget' method above "
                + "which should tell the game not to present a migration."
            )

        root = Node.void("IIDX25pc")
        root.set_attribute("name", profile.get_str("name"))
        root.set_attribute("idstr", ID.format_extid(profile.extid))
        root.set_attribute("pid", str(profile.get_int("pid")))
        return root

    def handle_IIDX25pc_takeover_request(self, request: Node) -> Node:
        refid = request.attribute("rid")
        name = request.attribute("name")
        pid = int(request.attribute("pid"))
        newprofile = self.new_profile_by_refid(refid, name, pid)

        root = Node.void("IIDX25pc")
        if newprofile is not None:
            root.set_attribute("id", str(newprofile.extid))
        return root

    def handle_IIDX25pc_reg_request(self, request: Node) -> Node:
        refid = request.attribute("rid")
        name = request.attribute("name")
        pid = int(request.attribute("pid"))
        profile = self.new_profile_by_refid(refid, name, pid)

        root = Node.void("IIDX25pc")
        if profile is not None:
            root.set_attribute("id", str(profile.extid))
            root.set_attribute("id_str", ID.format_extid(profile.extid))
        return root

    def handle_IIDX25pc_get_request(self, request: Node) -> Node:
        refid = request.attribute("rid")
        root = self.get_profile_by_refid(refid)
        if root is None:
            root = Node.void("IIDX25pc")
        return root

    def handle_IIDX25pc_save_request(self, request: Node) -> Node:
        extid = int(request.attribute("iidxid"))
        self.put_profile_by_extid(extid, request)

        return Node.void("IIDX25pc")

    def handle_IIDX25pc_logout_request(self, request: Node) -> Node:
        return Node.void("IIDX25pc")

    def handle_IIDX25gameSystem_systemInfo_request(self, request: Node) -> Node:
        root = Node.void("IIDX25gameSystem")
        arena_schedule = Node.void("arena_schedule")
        root.add_child(arena_schedule)
        arena_schedule.add_child(Node.u8("phase", 1))
        arena_schedule.add_child(Node.u32("start", 0))
        arena_schedule.add_child(Node.u32("end", 0))
        cpu_grades = [
            6,
            7,
            8,
            9,
            10,
            10,
            11,
            11,
            12,
            12,
            13,
            13,
            14,
            14,
            15,
            15,
            16,
            16,
            17,
            18,
        ]
        cpu_low_diff = [
            4,
            5,
            6,
            6,
            7,
            7,
            8,
            8,
            9,
            9,
            9,
            10,
            10,
            10,
            11,
            11,
            11,
            11,
            12,
            12,
        ]
        cpu_high_diff = [
            5,
            6,
            6,
            7,
            7,
            8,
            8,
            9,
            9,
            10,
            10,
            10,
            11,
            11,
            11,
            12,
            12,
            12,
            12,
            12,
        ]
        for playstyle in range(2):
            for arena_class in range(20):
                arena_music_difficult = Node.void("arena_music_difficult")
                root.add_child(arena_music_difficult)
                arena_music_difficult.add_child(Node.s32("play_style", playstyle))
                arena_music_difficult.add_child(Node.s32("arena_class", arena_class))
                arena_music_difficult.add_child(Node.s32("low_difficult", 1))
                arena_music_difficult.add_child(Node.s32("high_difficult", 12))
                arena_music_difficult.add_child(Node.bool("is_leggendaria", True))
                arena_music_difficult.add_child(Node.s32("force_music_list_id", 0))
                arena_cpu_define = Node.void("arena_cpu_define")
                root.add_child(arena_cpu_define)
                arena_cpu_define.add_child(Node.s32("play_style", playstyle))
                arena_cpu_define.add_child(Node.s32("arena_class", arena_class))
                arena_cpu_define.add_child(
                    Node.s32("grade_id", cpu_grades[arena_class])
                )
                arena_cpu_define.add_child(
                    Node.s32("low_music_difficult", cpu_low_diff[arena_class])
                )
                arena_cpu_define.add_child(
                    Node.s32("high_music_difficult", cpu_high_diff[arena_class])
                )
                arena_cpu_define.add_child(
                    Node.bool("is_leggendaria", arena_class >= 13)
                )
            for matching_class in range(21):
                matching_class_range = Node.void("matching_class_range")
                root.add_child(matching_class_range)
                matching_class_range.add_child(Node.s32("play_style", playstyle))
                matching_class_range.add_child(
                    Node.s32("matching_class", matching_class)
                )
                matching_class_range.add_child(Node.s32("low_arena_class", 1))
                matching_class_range.add_child(Node.s32("high_arena_class", 20))
        return root

    def handle_IIDX25pc_eaappliresult_request(self, request: Node) -> Node:
        clear_map = {
            self.GAME_CLEAR_STATUS_NO_PLAY: "NO PLAY",
            self.GAME_CLEAR_STATUS_FAILED: "FAILED",
            self.GAME_CLEAR_STATUS_ASSIST_CLEAR: "ASSIST CLEAR",
            self.GAME_CLEAR_STATUS_EASY_CLEAR: "EASY CLEAR",
            self.GAME_CLEAR_STATUS_CLEAR: "CLEAR",
            self.GAME_CLEAR_STATUS_HARD_CLEAR: "HARD CLEAR",
            self.GAME_CLEAR_STATUS_EX_HARD_CLEAR: "EX HARD CLEAR",
            self.GAME_CLEAR_STATUS_FULL_COMBO: "FULL COMBO",
        }
        # first we'll grab the data from the packet
        # did = request.child_value('did')
        # rid = request.child_value('rid')
        name = request.child_value("name")
        # qpro_hair = request.child_value('qpro_hair')
        # qpro_head = request.child_value('qpro_head')
        # qpro_body = request.child_value('qpro_body')
        # qpro_hand = request.child_value('qpro_hand')
        music_id = request.child_value("music_id")
        class_id = request.child_value("class_id")
        # no_save = request.child_value('no_save')
        # is_couple = request.child_value('is_couple')
        # target_graph = request.child_value('target_graph')
        target_exscore = request.child_value("target_exscore")
        # pacemaker = request.child_value('pacemaker')
        best_clear = request.child_value("best_clear")
        # best_djlevel = request.child_value('best_djlevel')
        # best_exscore = request.child_value('best_exscore')
        # best_misscount = request.child_value('best_misscount')
        now_clear = request.child_value("now_clear")
        # now_djlevel = request.child_value('now_djlevel')
        now_exscore = request.child_value("now_exscore")
        # now_misscount = request.child_value('now_misscount')
        now_pgreat = request.child_value("now_pgreat")
        now_great = request.child_value("now_great")
        now_good = request.child_value("now_good")
        now_bad = request.child_value("now_bad")
        now_poor = request.child_value("now_poor")
        now_combo = request.child_value("now_combo")
        now_fast = request.child_value("now_fast")
        now_slow = request.child_value("now_slow")
        best_clear_string = clear_map.get(best_clear, "NO PLAY")
        now_clear_string = clear_map.get(now_clear, "NO PLAY")
        # let's get the song info first
        song = self.data.local.music.get_song(
            self.game, self.music_version, music_id, self.game_to_db_chart(class_id)
        )
        notecount = song.data.get("notecount", 0)
        # Construct the dictionary for the broadcast
        card_data = {
            BroadcastConstants.DJ_NAME: name,
            BroadcastConstants.SONG_NAME: song.name,
            BroadcastConstants.ARTIST_NAME: song.artist,
            BroadcastConstants.DIFFICULTY: song.data.get("difficulty", 0),
            BroadcastConstants.TARGET_EXSCORE: target_exscore,
            BroadcastConstants.EXSCORE: now_exscore,
            BroadcastConstants.BEST_CLEAR_STATUS: best_clear_string,
            BroadcastConstants.CLEAR_STATUS: now_clear_string,
            BroadcastConstants.PLAY_STATS_HEADER: "How did you do?",
            BroadcastConstants.PERFECT_GREATS: now_pgreat,
            BroadcastConstants.GREATS: now_great,
            BroadcastConstants.GOODS: now_good,
            BroadcastConstants.BADS: now_bad,
            BroadcastConstants.POORS: now_poor,
            BroadcastConstants.COMBO_BREAKS: now_combo,
            BroadcastConstants.SLOWS: now_slow,
            BroadcastConstants.FASTS: now_fast,
        }
        if notecount != 0:
            max_score = notecount * 2
            percent = now_exscore / max_score
            grade = int(9 * percent)
            grades = ["F", "F", "E", "D", "C", "B", "A", "AA", "AAA", "MAX"]
            card_data[BroadcastConstants.GRADE] = grades[grade]
            card_data[BroadcastConstants.RATE] = str(round(percent, 2))

        # Try to broadcast out the score to our webhook(s)
        self.data.triggers.broadcast_score(card_data, self.game, song)

        return Node.void("IIDX25pc")

    def format_profile(self, userid: UserID, profile: Profile) -> Node:
        root = Node.void("IIDX25pc")

        # Look up play stats we bridge to every mix
        play_stats = self.get_play_statistics(userid)

        # Look up judge window adjustments
        judge_dict = profile.get_dict("machine_judge_adjust")
        machine_judge = judge_dict.get_dict(self.config.machine.pcbid)

        # Profile data
        pcdata = Node.void("pcdata")
        root.add_child(pcdata)
        pcdata.set_attribute("id", str(profile.extid))
        pcdata.set_attribute("idstr", ID.format_extid(profile.extid))
        pcdata.set_attribute("name", profile.get_str("name"))
        pcdata.set_attribute("pid", str(profile.get_int("pid")))
        pcdata.set_attribute("spnum", str(play_stats.get_int("single_plays")))
        pcdata.set_attribute("dpnum", str(play_stats.get_int("double_plays")))
        pcdata.set_attribute("sach", str(play_stats.get_int("single_dj_points")))
        pcdata.set_attribute("dach", str(play_stats.get_int("double_dj_points")))
        pcdata.set_attribute("mode", str(profile.get_int("mode")))
        pcdata.set_attribute("pmode", str(profile.get_int("pmode")))
        pcdata.set_attribute("rtype", str(profile.get_int("rtype")))
        pcdata.set_attribute("sp_opt", str(profile.get_int("sp_opt")))
        pcdata.set_attribute("dp_opt", str(profile.get_int("dp_opt")))
        pcdata.set_attribute("dp_opt2", str(profile.get_int("dp_opt2")))
        pcdata.set_attribute("gpos", str(profile.get_int("gpos")))
        pcdata.set_attribute("s_sorttype", str(profile.get_int("s_sorttype")))
        pcdata.set_attribute("d_sorttype", str(profile.get_int("d_sorttype")))
        pcdata.set_attribute("s_pace", str(profile.get_int("s_pace")))
        pcdata.set_attribute("d_pace", str(profile.get_int("d_pace")))
        pcdata.set_attribute("s_gno", str(profile.get_int("s_gno")))
        pcdata.set_attribute("d_gno", str(profile.get_int("d_gno")))
        pcdata.set_attribute("s_gtype", str(profile.get_int("s_gtype")))
        pcdata.set_attribute("d_gtype", str(profile.get_int("d_gtype")))
        pcdata.set_attribute("s_sdlen", str(profile.get_int("s_sdlen")))
        pcdata.set_attribute("d_sdlen", str(profile.get_int("d_sdlen")))
        pcdata.set_attribute("s_sdtype", str(profile.get_int("s_sdtype")))
        pcdata.set_attribute("d_sdtype", str(profile.get_int("d_sdtype")))
        pcdata.set_attribute("s_timing", str(profile.get_int("s_timing")))
        pcdata.set_attribute("d_timing", str(profile.get_int("d_timing")))
        pcdata.set_attribute("s_notes", str(profile.get_float("s_notes")))
        pcdata.set_attribute("d_notes", str(profile.get_float("d_notes")))
        pcdata.set_attribute("s_judge", str(profile.get_int("s_judge")))
        pcdata.set_attribute("d_judge", str(profile.get_int("d_judge")))
        pcdata.set_attribute("s_judgeAdj", str(machine_judge.get_int("single")))
        pcdata.set_attribute("d_judgeAdj", str(machine_judge.get_int("double")))
        pcdata.set_attribute("s_hispeed", str(profile.get_float("s_hispeed")))
        pcdata.set_attribute("d_hispeed", str(profile.get_float("d_hispeed")))
        pcdata.set_attribute("s_liflen", str(profile.get_int("s_lift")))
        pcdata.set_attribute("d_liflen", str(profile.get_int("d_lift")))
        pcdata.set_attribute("s_disp_judge", str(profile.get_int("s_disp_judge")))
        pcdata.set_attribute("d_disp_judge", str(profile.get_int("d_disp_judge")))
        pcdata.set_attribute("s_opstyle", str(profile.get_int("s_opstyle")))
        pcdata.set_attribute("d_opstyle", str(profile.get_int("d_opstyle")))
        pcdata.set_attribute("s_exscore", str(profile.get_int("s_exscore")))
        pcdata.set_attribute("d_exscore", str(profile.get_int("d_exscore")))
        pcdata.set_attribute("s_graph_score", str(profile.get_int("s_graph_score")))
        pcdata.set_attribute("d_graph_score", str(profile.get_int("d_graph_score")))
        pcdata.set_attribute("s_auto_scrach", str(profile.get_int("s_auto_scrach")))
        pcdata.set_attribute("d_auto_scrach", str(profile.get_int("d_auto_scrach")))
        pcdata.set_attribute("s_gauge_disp", str(profile.get_int("s_gauge_disp")))
        pcdata.set_attribute("d_gauge_disp", str(profile.get_int("d_gauge_disp")))
        pcdata.set_attribute("s_lane_brignt", str(profile.get_int("s_lane_brignt")))
        pcdata.set_attribute("d_lane_brignt", str(profile.get_int("d_lane_brignt")))
        pcdata.set_attribute("s_camera_layout", str(profile.get_int("s_camera_layout")))
        pcdata.set_attribute("d_camera_layout", str(profile.get_int("d_camera_layout")))

        spdp_rival = Node.void("spdp_rival")
        root.add_child(spdp_rival)
        spdp_rival.set_attribute("flg", str(profile.get_int("spdp_rival_flag")))

        premium_unlocks = Node.void("ea_premium_course")
        root.add_child(premium_unlocks)

        legendarias = Node.void("leggendaria_open")
        root.add_child(legendarias)

        # Song unlock flags
        secret_dict = profile.get_dict("secret")
        secret = Node.void("secret")
        root.add_child(secret)
        secret.add_child(Node.s64_array("flg1", secret_dict.get_int_array("flg1", 3)))
        secret.add_child(Node.s64_array("flg2", secret_dict.get_int_array("flg2", 3)))
        secret.add_child(Node.s64_array("flg3", secret_dict.get_int_array("flg3", 3)))

        # Favorites
        for folder in ["favorite1", "favorite2", "favorite3"]:
            favorite_dict = profile.get_dict(folder)
            sp_mlist = b""
            sp_clist = b""
            singles_list = favorite_dict["single"] if "single" in favorite_dict else []
            for single in singles_list:
                sp_mlist = sp_mlist + struct.pack("<L", single["id"])
                sp_clist = sp_clist + struct.pack("B", single["chart"])
            while len(sp_mlist) < (4 * self.FAVORITE_LIST_LENGTH):
                sp_mlist = sp_mlist + b"\x00\x00\x00\x00"
            while len(sp_clist) < self.FAVORITE_LIST_LENGTH:
                sp_clist = sp_clist + b"\x00"

            dp_mlist = b""
            dp_clist = b""
            doubles_list = favorite_dict["double"] if "double" in favorite_dict else []
            for double in doubles_list:
                dp_mlist = dp_mlist + struct.pack("<L", double["id"])
                dp_clist = dp_clist + struct.pack("B", double["chart"])
            while len(dp_mlist) < (4 * self.FAVORITE_LIST_LENGTH):
                dp_mlist = dp_mlist + b"\x00\x00\x00\x00"
            while len(dp_clist) < self.FAVORITE_LIST_LENGTH:
                dp_clist = dp_clist + b"\x00"

            if folder == "favorite1":
                favorite = Node.void("favorite")
            elif folder == "favorite2":
                favorite = Node.void("extra_favorite")
                favorite.set_attribute("folder_id", "0")
            elif folder == "favorite3":
                favorite = Node.void("extra_favorite")
                favorite.set_attribute("folder_id", "1")
            root.add_child(favorite)
            favorite.add_child(Node.binary("sp_mlist", sp_mlist))
            favorite.add_child(Node.binary("sp_clist", sp_clist))
            favorite.add_child(Node.binary("dp_mlist", dp_mlist))
            favorite.add_child(Node.binary("dp_clist", dp_clist))

        # DAN rankings
        grade = Node.void("grade")
        root.add_child(grade)
        grade.set_attribute(
            "sgid",
            str(
                self.db_to_game_rank(
                    profile.get_int(self.DAN_RANKING_SINGLE, -1),
                    self.GAME_CLTYPE_SINGLE,
                )
            ),
        )
        grade.set_attribute(
            "dgid",
            str(
                self.db_to_game_rank(
                    profile.get_int(self.DAN_RANKING_DOUBLE, -1),
                    self.GAME_CLTYPE_DOUBLE,
                )
            ),
        )
        achievements = self.data.local.user.get_achievements(
            self.game, self.version, userid
        )
        for rank in achievements:
            if rank.type == self.DAN_RANKING_SINGLE:
                grade.add_child(
                    Node.u8_array(
                        "g",
                        [
                            self.GAME_CLTYPE_SINGLE,
                            self.db_to_game_rank(rank.id, self.GAME_CLTYPE_SINGLE),
                            rank.data.get_int("stages_cleared"),
                            rank.data.get_int("percent"),
                        ],
                    )
                )
            if rank.type == self.DAN_RANKING_DOUBLE:
                grade.add_child(
                    Node.u8_array(
                        "g",
                        [
                            self.GAME_CLTYPE_DOUBLE,
                            self.db_to_game_rank(rank.id, self.GAME_CLTYPE_DOUBLE),
                            rank.data.get_int("stages_cleared"),
                            rank.data.get_int("percent"),
                        ],
                    )
                )

        # User settings
        settings_dict = profile.get_dict("settings")
        skin = Node.s16_array(
            "skin",
            [
                settings_dict.get_int("frame"),
                settings_dict.get_int("turntable"),
                settings_dict.get_int("burst"),
                settings_dict.get_int("bgm"),
                settings_dict.get_int("flags"),
                settings_dict.get_int("towel"),
                settings_dict.get_int("judge_pos"),
                settings_dict.get_int("voice"),
                settings_dict.get_int("noteskin"),
                settings_dict.get_int("full_combo"),
                settings_dict.get_int("beam"),
                settings_dict.get_int("judge"),
                0,
                settings_dict.get_int("disable_song_preview"),
                settings_dict.get_int("pacemaker"),
                settings_dict.get_int("effector_lock"),
                settings_dict.get_int("effector_preset"),
            ],
        )
        root.add_child(skin)

        # Qpro data
        qpro_dict = profile.get_dict("qpro")
        root.add_child(
            Node.u32_array(
                "qprodata",
                [
                    qpro_dict.get_int("head"),
                    qpro_dict.get_int("hair"),
                    qpro_dict.get_int("face"),
                    qpro_dict.get_int("hand"),
                    qpro_dict.get_int("body"),
                ],
            )
        )

        # Qpro secret data from step-up mode
        qpro_secrete_dict = profile.get_dict("qpro_secret")
        qpro_secret = Node.void("qpro_secret")
        root.add_child(qpro_secret)
        qpro_secret.add_child(
            Node.s64_array("head", qpro_secrete_dict.get_int_array("head", 5))
        )
        qpro_secret.add_child(
            Node.s64_array("hair", qpro_secrete_dict.get_int_array("hair", 5))
        )
        qpro_secret.add_child(
            Node.s64_array("face", qpro_secrete_dict.get_int_array("face", 5))
        )
        qpro_secret.add_child(
            Node.s64_array("body", qpro_secrete_dict.get_int_array("body", 5))
        )
        qpro_secret.add_child(
            Node.s64_array("hand", qpro_secrete_dict.get_int_array("hand", 5))
        )

        # Rivals
        rlist = Node.void("rlist")
        root.add_child(rlist)
        links = self.data.local.user.get_links(self.game, self.version, userid)
        for link in links:
            rival_type = None
            if link.type == "sp_rival":
                rival_type = "1"
            elif link.type == "dp_rival":
                rival_type = "2"
            else:
                # No business with this link type
                continue

            other_profile = self.get_profile(link.other_userid)
            if other_profile is None:
                continue
            other_play_stats = self.get_play_statistics(link.other_userid)

            rival = Node.void("rival")
            rlist.add_child(rival)
            rival.set_attribute("spdp", rival_type)
            rival.set_attribute("id", str(other_profile.extid))
            rival.set_attribute("id_str", ID.format_extid(other_profile.extid))
            rival.set_attribute("djname", other_profile.get_str("name"))
            rival.set_attribute("pid", str(other_profile.get_int("pid")))
            rival.set_attribute(
                "sg",
                str(
                    self.db_to_game_rank(
                        other_profile.get_int(self.DAN_RANKING_SINGLE, -1),
                        self.GAME_CLTYPE_SINGLE,
                    )
                ),
            )
            rival.set_attribute(
                "dg",
                str(
                    self.db_to_game_rank(
                        other_profile.get_int(self.DAN_RANKING_DOUBLE, -1),
                        self.GAME_CLTYPE_DOUBLE,
                    )
                ),
            )
            rival.set_attribute("sa", str(other_play_stats.get_int("single_dj_points")))
            rival.set_attribute("da", str(other_play_stats.get_int("double_dj_points")))

            rival.add_child(Node.bool("is_robo", False))

            qprodata = Node.void("qprodata")
            rival.add_child(qprodata)
            qpro = other_profile.get_dict("qpro")
            qprodata.set_attribute("head", str(qpro.get_int("head")))
            qprodata.set_attribute("hair", str(qpro.get_int("hair")))
            qprodata.set_attribute("face", str(qpro.get_int("face")))
            qprodata.set_attribute("body", str(qpro.get_int("body")))
            qprodata.set_attribute("hand", str(qpro.get_int("hand")))

        # Expert courses
        ir_data = Node.void("ir_data")
        root.add_child(ir_data)
        for course in achievements:
            if course.type == self.COURSE_TYPE_INTERNET_RANKING:
                courseid, coursechart = self.id_and_chart_from_courseid(course.id)
                ir_data.add_child(
                    Node.s32_array(
                        "e",
                        [
                            courseid,  # course ID
                            coursechart,  # course chart
                            self.db_to_game_status(
                                course.data.get_int("clear_status")
                            ),  # course clear status
                            course.data.get_int("pgnum"),  # flashing great count
                            course.data.get_int("gnum"),  # great count
                        ],
                    )
                )

        secret_course_data = Node.void("secret_course_data")
        root.add_child(secret_course_data)
        for course in achievements:
            if course.type == self.COURSE_TYPE_SECRET:
                courseid, coursechart = self.id_and_chart_from_courseid(course.id)
                secret_course_data.add_child(
                    Node.s32_array(
                        "e",
                        [
                            courseid,  # course ID
                            coursechart,  # course chart
                            self.db_to_game_status(
                                course.data.get_int("clear_status")
                            ),  # course clear status
                            course.data.get_int("pgnum"),  # flashing great count
                            course.data.get_int("gnum"),  # great count
                        ],
                    )
                )

        classic_course_data = Node.void("classic_course_data")
        root.add_child(classic_course_data)
        for course in achievements:
            if course.type == self.COURSE_TYPE_CLASSIC:
                courseid, playstyle = self.id_and_chart_from_courseid(course.id)
                score_data = Node.void("score_data")
                classic_course_data.add_child(score_data)
                score_data.set_attribute("play_style", str(playstyle))
                score_data.set_attribute("course_id", str(courseid))
                score_data.set_attribute(
                    "score",
                    str(course.data.get_int("pgnum") * 2 + course.data.get_int("gnum")),
                )
                score_data.set_attribute("pgnum", str(course.data.get_int("pgnum")))
                score_data.set_attribute("gnum", str(course.data.get_int("gnum")))
                score_data.set_attribute(
                    "cflg",
                    str(self.db_to_game_status(course.data.get_int("clear_status"))),
                )

        # DJ RANK
        for dj_rank in achievements:
            if dj_rank.type != "dj_rank":
                continue

            dj_rank_node = Node.void("dj_rank")
            root.add_child(dj_rank_node)
            dj_rank_node.set_attribute("style", str(dj_rank.id))
            dj_rank_node.add_child(
                Node.s32_array("rank", dj_rank.data.get_int_array("rank", 15))
            )
            dj_rank_node.add_child(
                Node.s32_array("point", dj_rank.data.get_int_array("point", 15))
            )

        for i in range(2):
            for j in range(15):
                dj_rank_ranking_node = Node.void("dj_rank_ranking")
                root.add_child(dj_rank_ranking_node)
                dj_rank_ranking_node.set_attribute("style", str(i))
                detail = Node.void("detail")
                dj_rank_ranking_node.add_child(detail)
                detail.set_attribute("category", str(j))
                detail.set_attribute("total_user", "0")
                detail.set_attribute("rank", "0")
                detail.set_attribute("platinum_point", "0")
                detail.set_attribute("platinum_rank", "0")
                detail.set_attribute("gold_point", "0")
                detail.set_attribute("gold_rank", "0")
                detail.set_attribute("silver_point", "0")
                detail.set_attribute("silver_rank", "0")
                detail.set_attribute("bronze_point", "0")
                detail.set_attribute("bronze_rank", "0")
                detail.set_attribute("white_point", "0")
                detail.set_attribute("white_rank", "0")

        event1_dict = profile.get_dict("event1")
        event1 = Node.void("event1")
        root.add_child(event1)
        event1.set_attribute("tuneup_point", str(event1_dict.get_int("tuneup_point")))
        event1.set_attribute(
            "body_parts_list", str(event1_dict.get_int("body_parts_list"))
        )
        event1.set_attribute(
            "engine_parts_list", str(event1_dict.get_int("engine_parts_list"))
        )
        event1.set_attribute(
            "tire_parts_list", str(event1_dict.get_int("tire_parts_list"))
        )
        event1.set_attribute(
            "body_equip_parts", str(event1_dict.get_int("body_equip_parts"))
        )
        event1.set_attribute(
            "engine_equip_parts", str(event1_dict.get_int("engine_equip_parts"))
        )
        event1.set_attribute(
            "tire_equip_parts", str(event1_dict.get_int("tire_equip_parts"))
        )
        event1.set_attribute("gift_point", str(event1_dict.get_int("play_gift")))

        for map_data in achievements:
            if map_data.type != "map_data":
                continue
            map_data_node = Node.void("map_data")
            event1.add_child(map_data_node)
            map_data_node.set_attribute("map_id", str(map_data.id))
            map_data_node.set_attribute(
                "play_num", str(map_data.data.get_int("play_num"))
            )
            map_data_node.set_attribute(
                "progress", str(map_data.data.get_int("progress"))
            )
            map_data_node.set_attribute(
                "boost_fuel", str(map_data.data.get_int("boost_fuel"))
            )
            map_data_node.set_attribute(
                "is_clear", str(map_data.data.get_int("is_clear"))
            )
            map_data_node.set_attribute(
                "rare_defeat_list", str(map_data.data.get_int("rare_defeat_list"))
            )
            map_data_node.set_attribute(
                "rare1_appearance", str(map_data.data.get_int("rare1_appearance"))
            )
            map_data_node.set_attribute(
                "rare2_appearance", str(map_data.data.get_int("rare2_appearance"))
            )
            map_data_node.set_attribute(
                "rare3_appearance", str(map_data.data.get_int("rare3_appearance"))
            )
            map_data_node.set_attribute(
                "rare4_appearance", str(map_data.data.get_int("rare4_appearance"))
            )
            map_data_node.set_attribute(
                "rare5_appearance", str(map_data.data.get_int("rare5_appearance"))
            )
            map_data_node.set_attribute(
                "rare6_appearance", str(map_data.data.get_int("rare6_appearance"))
            )

        # OMES Data
        omes_dict = profile.get_dict("omes")
        onemore_data = Node.void("onemore_event")
        root.add_child(onemore_data)
        for i in range(6):
            onemore_data.set_attribute(
                f"defeat_{i}", str(omes_dict.get_int(f"defeat_{i}"))
            )
        for i in range(3):
            i = i + 1
            onemore_data.set_attribute(
                f"challenge_num_{i}_n", str(omes_dict.get_int(f"challenge_num_{i}_n"))
            )
            onemore_data.set_attribute(
                f"challenge_num_{i}_h", str(omes_dict.get_int(f"challenge_num_{i}_h"))
            )
            onemore_data.set_attribute(
                f"challenge_num_{i}_a", str(omes_dict.get_int(f"challenge_num_{i}_a"))
            )

        # Step up mode
        step_dict = profile.get_dict("step")
        step = Node.void("step")
        root.add_child(step)
        step.set_attribute("enemy_damage", str(step_dict.get_int("enemy_damage")))
        step.set_attribute("progress", str(step_dict.get_int("progress")))
        step.set_attribute("point", str(step_dict.get_int("point")))
        step.set_attribute(
            "enemy_defeat_flg", str(step_dict.get_int("enemy_defeat_flg"))
        )
        step.set_attribute("sp_level", str(step_dict.get_int("sp_level")))
        step.set_attribute("dp_level", str(step_dict.get_int("dp_level")))
        step.set_attribute("sp_mplay", str(step_dict.get_int("sp_mplay")))
        step.set_attribute("dp_mplay", str(step_dict.get_int("dp_mplay")))

        # Daily recommendations
        entry = self.data.local.game.get_time_sensitive_settings(
            self.game, self.version, "dailies"
        )
        if entry is not None:
            packinfo = Node.void("packinfo")
            root.add_child(packinfo)

            pack_id = int(entry["start_time"] / 86400)
            packinfo.set_attribute("pack_id", str(pack_id))
            packinfo.set_attribute("music_0", str(entry["music"][0]))
            packinfo.set_attribute("music_1", str(entry["music"][1]))
            packinfo.set_attribute("music_2", str(entry["music"][2]))
        else:
            # No dailies :(
            pack_id = None

        # Tran medals and shit
        achievement_node = Node.void("achievements")
        root.add_child(achievement_node)

        # Dailies
        if pack_id is None:
            achievement_node.set_attribute("pack", "0")
            achievement_node.set_attribute("pack_comp", "0")
        else:
            daily_played = self.data.local.user.get_achievement(
                self.game, self.version, userid, pack_id, "daily"
            )
            if daily_played is None:
                daily_played = ValidatedDict()
            achievement_node.set_attribute(
                "pack", str(daily_played.get_int("pack_flg"))
            )
            achievement_node.set_attribute(
                "pack_comp", str(daily_played.get_int("pack_comp"))
            )

        # Weeklies
        achievement_node.set_attribute(
            "last_weekly", str(profile.get_int("last_weekly"))
        )
        achievement_node.set_attribute("weekly_num", str(profile.get_int("weekly_num")))

        # Prefecture visit flag
        achievement_node.set_attribute("visit_flg", str(profile.get_int("visit_flg")))

        # Number of rivals beaten
        achievement_node.set_attribute(
            "rival_crush", str(profile.get_int("rival_crush"))
        )

        # Tran medals
        achievement_node.add_child(
            Node.s64_array("trophy", profile.get_int_array("trophy", 20))
        )

        # Track deller
        deller = Node.void("deller")
        root.add_child(deller)
        deller.set_attribute("deller", str(profile.get_int("deller")))
        deller.set_attribute("rate", "0")

        # Orb data
        orb_data = Node.void("orb_data")
        root.add_child(orb_data)
        orb_data.set_attribute("rest_orb", str(profile.get_int("orbs")))

        # Expert points
        expert_point = Node.void("expert_point")
        root.add_child(expert_point)
        for rank in achievements:
            if rank.type == "expert_point":
                detail = Node.void("detail")
                expert_point.add_child(detail)
                detail.set_attribute("course_id", str(rank.id))
                detail.set_attribute("n_point", str(rank.data.get_int("normal_points")))
                detail.set_attribute("h_point", str(rank.data.get_int("hyper_points")))
                detail.set_attribute(
                    "a_point", str(rank.data.get_int("another_points"))
                )

        nostalgia = Node.void("nostalgia_open")
        root.add_child(nostalgia)

        # Ea app features
        if self.data.triggers.has_broadcast_destination(self.game):
            root.add_child(Node.void("bind_eaappli"))
            pay_per_use = Node.void("pay_per_use")
            root.add_child(pay_per_use)
            pay_per_use.set_attribute("item_num", "99")
        return root

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

        # Track play counts
        cltype = int(request.attribute("cltype"))
        if cltype == self.GAME_CLTYPE_SINGLE:
            play_stats.increment_int("single_plays")
        if cltype == self.GAME_CLTYPE_DOUBLE:
            play_stats.increment_int("double_plays")

        # Track DJ points
        play_stats.replace_int("single_dj_points", int(request.attribute("s_achi")))
        play_stats.replace_int("double_dj_points", int(request.attribute("d_achi")))

        # Profile settings
        newprofile.replace_int("sp_opt", int(request.attribute("sp_opt")))
        newprofile.replace_int("dp_opt", int(request.attribute("dp_opt")))
        newprofile.replace_int("dp_opt2", int(request.attribute("dp_opt2")))
        newprofile.replace_int("gpos", int(request.attribute("gpos")))
        newprofile.replace_int("s_sorttype", int(request.attribute("s_sorttype")))
        newprofile.replace_int("d_sorttype", int(request.attribute("d_sorttype")))
        newprofile.replace_int("s_disp_judge", int(request.attribute("s_disp_judge")))
        newprofile.replace_int("d_disp_judge", int(request.attribute("d_disp_judge")))
        newprofile.replace_int("s_pace", int(request.attribute("s_pace")))
        newprofile.replace_int("d_pace", int(request.attribute("d_pace")))
        newprofile.replace_int("s_gno", int(request.attribute("s_gno")))
        newprofile.replace_int("d_gno", int(request.attribute("d_gno")))
        newprofile.replace_int("s_gtype", int(request.attribute("s_gtype")))
        newprofile.replace_int("d_gtype", int(request.attribute("d_gtype")))
        newprofile.replace_int("s_sdlen", int(request.attribute("s_sdlen")))
        newprofile.replace_int("d_sdlen", int(request.attribute("d_sdlen")))
        newprofile.replace_int("s_sdtype", int(request.attribute("s_sdtype")))
        newprofile.replace_int("d_sdtype", int(request.attribute("d_sdtype")))
        newprofile.replace_int("s_timing", int(request.attribute("s_timing")))
        newprofile.replace_int("d_timing", int(request.attribute("d_timing")))
        newprofile.replace_float("s_notes", float(request.attribute("s_notes")))
        newprofile.replace_float("d_notes", float(request.attribute("d_notes")))
        newprofile.replace_int("s_judge", int(request.attribute("s_judge")))
        newprofile.replace_int("d_judge", int(request.attribute("d_judge")))
        newprofile.replace_float("s_hispeed", float(request.attribute("s_hispeed")))
        newprofile.replace_float("d_hispeed", float(request.attribute("d_hispeed")))
        newprofile.replace_int("s_opstyle", int(request.attribute("s_opstyle")))
        newprofile.replace_int("d_opstyle", int(request.attribute("d_opstyle")))
        newprofile.replace_int("s_graph_score", int(request.attribute("s_graph_score")))
        newprofile.replace_int("d_graph_score", int(request.attribute("d_graph_score")))
        newprofile.replace_int("s_auto_scrach", int(request.attribute("s_auto_scrach")))
        newprofile.replace_int("d_auto_scrach", int(request.attribute("d_auto_scrach")))
        newprofile.replace_int("s_gauge_disp", int(request.attribute("s_gauge_disp")))
        newprofile.replace_int("d_gauge_disp", int(request.attribute("d_gauge_disp")))
        newprofile.replace_int("s_lane_brignt", int(request.attribute("s_lane_brignt")))
        newprofile.replace_int("d_lane_brignt", int(request.attribute("d_lane_brignt")))
        newprofile.replace_int(
            "s_camera_layout", int(request.attribute("s_camera_layout"))
        )
        newprofile.replace_int(
            "d_camera_layout", int(request.attribute("d_camera_layout"))
        )
        newprofile.replace_int("s_lift", int(request.attribute("s_lift")))
        newprofile.replace_int("d_lift", int(request.attribute("d_lift")))
        newprofile.replace_int("mode", int(request.attribute("mode")))
        newprofile.replace_int("pmode", int(request.attribute("pmode")))
        newprofile.replace_int("rtype", int(request.attribute("rtype")))
        # Update judge window adjustments per-machine
        judge_dict = newprofile.get_dict("machine_judge_adjust")
        machine_judge = judge_dict.get_dict(self.config.machine.pcbid)
        machine_judge.replace_int("single", int(request.attribute("s_judgeAdj")))
        machine_judge.replace_int("double", int(request.attribute("d_judgeAdj")))
        judge_dict.replace_dict(self.config.machine.pcbid, machine_judge)
        newprofile.replace_dict("machine_judge_adjust", judge_dict)

        # Secret flags saving
        secret = request.child("secret")
        if secret is not None:
            secret_dict = newprofile.get_dict("secret")
            secret_dict.replace_int_array("flg1", 3, secret.child_value("flg1"))
            secret_dict.replace_int_array("flg2", 3, secret.child_value("flg2"))
            secret_dict.replace_int_array("flg3", 3, secret.child_value("flg3"))
            newprofile.replace_dict("secret", secret_dict)

        # Basic achievements
        achievements = request.child("achievements")
        if achievements is not None:
            newprofile.replace_int(
                "visit_flg", int(achievements.attribute("visit_flg"))
            )
            newprofile.replace_int(
                "last_weekly", int(achievements.attribute("last_weekly"))
            )
            newprofile.replace_int(
                "weekly_num", int(achievements.attribute("weekly_num"))
            )

            pack_id = int(achievements.attribute("pack_id"))
            if pack_id > 0:
                self.data.local.user.put_achievement(
                    self.game,
                    self.version,
                    userid,
                    pack_id,
                    "daily",
                    {
                        "pack_flg": int(achievements.attribute("pack_flg")),
                        "pack_comp": int(achievements.attribute("pack_comp")),
                    },
                )

            trophies = achievements.child("trophy")
            if trophies is not None:
                # We only load the first 20 in profile load.
                newprofile.replace_int_array("trophy", 20, trophies.value[:20])

        # Deller saving
        deller = request.child("deller")
        if deller is not None:
            newprofile.replace_int(
                "deller", newprofile.get_int("deller") + int(deller.attribute("deller"))
            )

        # Secret course expert point saving
        expert_point = request.child("expert_point")
        if expert_point is not None:
            courseid = int(expert_point.attribute("course_id"))

            # Update achievement to track expert points
            expert_point_achievement = self.data.local.user.get_achievement(
                self.game,
                self.version,
                userid,
                courseid,
                "expert_point",
            )
            if expert_point_achievement is None:
                expert_point_achievement = ValidatedDict()
            expert_point_achievement.replace_int(
                "normal_points",
                int(expert_point.attribute("n_point")),
            )
            expert_point_achievement.replace_int(
                "hyper_points",
                int(expert_point.attribute("h_point")),
            )
            expert_point_achievement.replace_int(
                "another_points",
                int(expert_point.attribute("a_point")),
            )

            self.data.local.user.put_achievement(
                self.game,
                self.version,
                userid,
                courseid,
                "expert_point",
                expert_point_achievement,
            )

        # Favorites saving
        for favorite in request.children:
            singles = []
            doubles = []
            name = None
            if favorite.name in ["favorite", "extra_favorite"]:
                if favorite.name == "favorite":
                    name = "favorite1"
                elif favorite.name == "extra_favorite":
                    folder = favorite.attribute("folder_id")
                    if folder == "0":
                        name = "favorite2"
                    if folder == "1":
                        name = "favorite3"
                if name is None:
                    continue

                single_music_bin = favorite.child_value("sp_mlist")
                single_chart_bin = favorite.child_value("sp_clist")
                double_music_bin = favorite.child_value("dp_mlist")
                double_chart_bin = favorite.child_value("dp_clist")

                for i in range(self.FAVORITE_LIST_LENGTH):
                    singles.append(
                        {
                            "id": struct.unpack(
                                "<L", single_music_bin[(i * 4) : ((i + 1) * 4)]
                            )[0],
                            "chart": struct.unpack("B", single_chart_bin[i : (i + 1)])[
                                0
                            ],
                        }
                    )
                    doubles.append(
                        {
                            "id": struct.unpack(
                                "<L", double_music_bin[(i * 4) : ((i + 1) * 4)]
                            )[0],
                            "chart": struct.unpack("B", double_chart_bin[i : (i + 1)])[
                                0
                            ],
                        }
                    )

            # Filter out empty charts
            if name is not None:
                singles = [single for single in singles if single["id"] != 0]
                doubles = [double for double in doubles if double["id"] != 0]

                newprofile.replace_dict(
                    name,
                    {
                        "single": singles,
                        "double": doubles,
                    },
                )

        # DJ rank saving
        for dj_rank in request.children:
            if dj_rank.name != "dj_rank":
                continue

            rankid = int(dj_rank.attribute("style"))
            rank = dj_rank.child_value("rank")
            point = dj_rank.child_value("point")
            self.data.local.user.put_achievement(
                self.game,
                self.version,
                userid,
                rankid,
                "dj_rank",
                {
                    "rank": rank,
                    "point": point,
                },
            )

        # Gekisou! Cannon racer Event Saving
        event1 = request.child("event1")
        if event1 is not None:
            event1_dict = newprofile.get_dict("event1")
            event1_dict.replace_int(
                "tuneup_point", int(event1.attribute("tuneup_point"))
            )
            event1_dict.replace_int(
                "body_parts_list", int(event1.attribute("body_parts_list"))
            )
            event1_dict.replace_int(
                "engine_parts_list", int(event1.attribute("engine_parts_list"))
            )
            event1_dict.replace_int(
                "tire_parts_list", int(event1.attribute("tire_parts_list"))
            )
            event1_dict.replace_int(
                "body_equip_parts", int(event1.attribute("body_equip_parts"))
            )
            event1_dict.replace_int(
                "engine_equip_parts", int(event1.attribute("engine_equip_parts"))
            )
            event1_dict.replace_int(
                "tire_equip_parts", int(event1.attribute("tire_equip_parts"))
            )
            event1_dict.replace_int("play_gift", int(event1.attribute("play_gift")))
            event1_dict.replace_bool("is_use_gift", event1.child_value("is_use_gift"))
            for map_data in event1.children:
                if map_data.name != "map_data":
                    continue

                # Update the gym's progress in the DB
                map_id = int(map_data.attribute("map_id"))
                play_num = int(map_data.attribute("play_num"))
                is_clear = map_data.child_value("is_clear") or False
                progress = int(map_data.attribute("progress"))
                boost_fuel = int(map_data.attribute("boost_fuel"))
                rare_defeat_list = int(map_data.attribute("rare_defeat_list"))
                rare1_appearance = int(map_data.attribute("rare1_appearance"))
                rare2_appearance = int(map_data.attribute("rare2_appearance"))
                rare3_appearance = int(map_data.attribute("rare3_appearance"))
                rare4_appearance = int(map_data.attribute("rare4_appearance"))
                rare5_appearance = int(map_data.attribute("rare5_appearance"))
                rare6_appearance = int(map_data.attribute("rare6_appearance"))
                self.data.local.user.put_achievement(
                    self.game,
                    self.version,
                    userid,
                    map_id,
                    "map_data",
                    {
                        "play_num": play_num,
                        "progress": progress,
                        "boost_fuel": boost_fuel,
                        "rare_defeat_list": rare_defeat_list,
                        "rare1_appearance": rare1_appearance,
                        "rare2_appearance": rare2_appearance,
                        "rare3_appearance": rare3_appearance,
                        "rare4_appearance": rare4_appearance,
                        "rare5_appearance": rare5_appearance,
                        "rare6_appearance": rare6_appearance,
                        "is_clear": is_clear,
                    },
                )

        # Step-up mode
        step = request.child("step")
        if step is not None:
            step_dict = newprofile.get_dict("step")
            step_dict.replace_int("enemy_damage", int(step.attribute("enemy_damage")))
            step_dict.replace_int("progress", int(step.attribute("progress")))
            step_dict.replace_int("point", int(step.attribute("point")))
            step_dict.replace_int(
                "enemy_defeat_flg", int(step.attribute("enemy_defeat_flg"))
            )
            step_dict.replace_int("sp_level", int(step.attribute("sp_level")))
            step_dict.replace_int("dp_level", int(step.attribute("dp_level")))
            step_dict.replace_int("sp_mplay", int(step.attribute("sp_mplay")))
            step_dict.replace_int("dp_mplay", int(step.attribute("dp_mplay")))
            newprofile.replace_dict("step", step_dict)

        # QPro equip in step-up mode
        qpro_equip = request.child("qpro_equip")
        if qpro_equip is not None:
            qpro_dict = newprofile.get_dict("qpro")
            qpro_dict.replace_int("head", int(qpro_equip.attribute("head")))
            qpro_dict.replace_int("hair", int(qpro_equip.attribute("hair")))
            qpro_dict.replace_int("face", int(qpro_equip.attribute("face")))
            qpro_dict.replace_int("hand", int(qpro_equip.attribute("hand")))
            qpro_dict.replace_int("body", int(qpro_equip.attribute("body")))
            newprofile.replace_dict("qpro", qpro_dict)

        # Qpro secret unlocks in step-up mode
        qpro_secret = request.child("qpro_secret")
        if qpro_secret is not None:
            qpro_secret_dict = newprofile.get_dict("qpro_secret")
            qpro_secret_dict.replace_int_array(
                "head", 5, qpro_secret.child_value("head")
            )
            qpro_secret_dict.replace_int_array(
                "hair", 5, qpro_secret.child_value("hair")
            )
            qpro_secret_dict.replace_int_array(
                "face", 5, qpro_secret.child_value("face")
            )
            qpro_secret_dict.replace_int_array(
                "body", 5, qpro_secret.child_value("body")
            )
            qpro_secret_dict.replace_int_array(
                "hand", 5, qpro_secret.child_value("hand")
            )
            newprofile.replace_dict("qpro_secret", qpro_secret_dict)

        # Orb data saving
        orb_data = request.child("orb_data")
        if orb_data is not None:
            orbs = newprofile.get_int("orbs")
            orbs = orbs + int(orb_data.attribute("add_orb"))
            if orb_data.child_value("use_vip_pass"):
                orbs = 0
            newprofile.replace_int("orbs", orbs)

        # OMES Tracking
        onemore_data = request.child("onemore_event")
        if onemore_data is not None:
            omes_dict = newprofile.get_dict("omes")
            for i in range(6):
                omes_dict.replace_int(
                    f"defeat_{i}", int(onemore_data.attribute(f"defeat_{i}"))
                )
            for i in range(3):
                i = i + 1
                omes_dict.replace_int(
                    f"challenge_num_{i}_n",
                    int(onemore_data.attribute(f"challenge_num_{i}_n")),
                )
                omes_dict.replace_int(
                    f"challenge_num_{i}_h",
                    int(onemore_data.attribute(f"challenge_num_{i}_h")),
                )
                omes_dict.replace_int(
                    f"challenge_num_{i}_a",
                    int(onemore_data.attribute(f"challenge_num_{i}_a")),
                )
            newprofile.replace_dict("omes", omes_dict)

        # Keep track of play statistics across all mixes
        self.update_play_statistics(userid, play_stats)

        return newprofile