bemaniutils/bemani/client/reflec/reflec.py

import random
import time
from typing import Dict, List, Optional

from bemani.common import Time
from bemani.client.base import BaseClient
from bemani.protocol import Node


class ReflecBeat(BaseClient):
    NAME = "ＴＥＳＴ"

    def verify_log_pcb_status(self, loc: str) -> None:
        call = self.call_node()

        pcb = Node.void("log")
        pcb.set_attribute("method", "pcb_status")
        pcb.add_child(Node.string("lid", loc))
        pcb.add_child(Node.u8("type", 0))
        call.add_child(pcb)

        # Swap with server
        resp = self.exchange("", call)

        # Verify that response is correct
        self.assert_path(resp, "response/log/@status")

    def verify_pcbinfo_get(self, loc: str) -> None:
        call = self.call_node()

        pcb = Node.void("pcbinfo")
        pcb.set_attribute("method", "get")
        pcb.add_child(Node.string("lid", loc))
        call.add_child(pcb)

        # Swap with server
        resp = self.exchange("", call)

        # Verify that response is correct
        self.assert_path(resp, "response/pcbinfo/info/name")
        self.assert_path(resp, "response/pcbinfo/info/pref")
        self.assert_path(resp, "response/pcbinfo/info/close")
        self.assert_path(resp, "response/pcbinfo/info/hour")
        self.assert_path(resp, "response/pcbinfo/info/min")

    def verify_sysinfo_get(self) -> None:
        call = self.call_node()

        info = Node.void("sysinfo")
        info.set_attribute("method", "get")
        call.add_child(info)

        # Swap with server
        resp = self.exchange("", call)

        # Verify that response is correct
        self.assert_path(resp, "response/sysinfo/trd")

    def verify_sysinfo_fan(self, loc: str) -> None:
        call = self.call_node()

        info = Node.void("sysinfo")
        info.set_attribute("method", "fan")
        info.add_child(Node.u8("pref", 0))
        info.add_child(Node.string("lid", loc))
        call.add_child(info)

        # Swap with server
        resp = self.exchange("", call)

        # Verify that response is correct
        self.assert_path(resp, "response/sysinfo/pref")
        self.assert_path(resp, "response/sysinfo/lid")

    def verify_player_start(self, refid: str) -> None:
        call = self.call_node()

        player = Node.void("player")
        player.set_attribute("method", "start")
        player.add_child(Node.string("rid", refid))
        player.add_child(Node.s32("ver", 3))
        call.add_child(player)

        # Swap with server
        resp = self.exchange("", call)

        # Verify that response is correct
        self.assert_path(resp, "response/player/is_suc")

    def verify_player_delete(self, refid: str) -> None:
        call = self.call_node()

        player = Node.void("player")
        player.set_attribute("method", "delete")
        player.add_child(Node.string("rid", refid))
        call.add_child(player)

        # Swap with server
        resp = self.exchange("", call)

        # Verify that response is correct
        self.assert_path(resp, "response/player/@status")

    def verify_player_end(self, refid: str) -> None:
        call = self.call_node()

        player = Node.void("player")
        player.set_attribute("method", "end")
        player.add_child(Node.string("rid", refid))
        call.add_child(player)

        # Swap with server
        resp = self.exchange("", call)

        # Verify that response is correct
        self.assert_path(resp, "response/player")

    def verify_player_read(self, refid: str, location: str) -> List[Dict[str, int]]:
        call = self.call_node()

        player = Node.void("player")
        player.set_attribute("method", "read")
        player.add_child(Node.string("rid", refid))
        player.add_child(Node.string("lid", location))
        player.add_child(Node.s32("ver", 3))
        call.add_child(player)

        # Swap with server
        resp = self.exchange("", call)

        # Verify that response is correct
        self.assert_path(resp, "response/player/pdata/base/uid")
        self.assert_path(resp, "response/player/pdata/base/name")
        self.assert_path(resp, "response/player/pdata/base/lv")
        self.assert_path(resp, "response/player/pdata/base/exp")
        self.assert_path(resp, "response/player/pdata/base/mg")
        self.assert_path(resp, "response/player/pdata/base/ap")
        self.assert_path(resp, "response/player/pdata/base/flag")
        self.assert_path(resp, "response/player/pdata/con/day")
        self.assert_path(resp, "response/player/pdata/con/cnt")
        self.assert_path(resp, "response/player/pdata/con/last")
        self.assert_path(resp, "response/player/pdata/con/now")
        self.assert_path(resp, "response/player/pdata/team/id")
        self.assert_path(resp, "response/player/pdata/team/name")
        self.assert_path(resp, "response/player/pdata/custom/bgm_m")
        self.assert_path(resp, "response/player/pdata/custom/st_f")
        self.assert_path(resp, "response/player/pdata/custom/st_bg")
        self.assert_path(resp, "response/player/pdata/custom/st_bg_b")
        self.assert_path(resp, "response/player/pdata/custom/eff_e")
        self.assert_path(resp, "response/player/pdata/custom/se_s")
        self.assert_path(resp, "response/player/pdata/custom/se_s_v")
        self.assert_path(resp, "response/player/pdata/released")
        self.assert_path(resp, "response/player/pdata/record")
        self.assert_path(resp, "response/player/pdata/blog")
        self.assert_path(resp, "response/player/pdata/cmnt")

        if resp.child_value("player/pdata/base/name") != self.NAME:
            raise Exception(f'Invalid name {resp.child_value("player/pdata/base/name")} returned on profile read!')

        scores = []
        for child in resp.child("player/pdata/record").children:
            if child.name != "rec":
                continue

            score = {
                "id": child.child_value("mid"),
                "chart": child.child_value("ng"),
                "clear_type": child.child_value("ct"),
                "achievement_rate": child.child_value("ar"),
                "score": child.child_value("bs"),
                "combo": child.child_value("mc"),
                "miss_count": child.child_value("bmc"),
            }
            scores.append(score)
        return scores

    def verify_player_write(
        self,
        refid: str,
        extid: int,
        loc: str,
        records: List[Dict[str, int]],
        scores: List[Dict[str, int]],
    ) -> int:
        call = self.call_node()

        player = Node.void("player")
        call.add_child(player)
        player.set_attribute("method", "write")
        player.add_child(Node.string("rid", refid))
        player.add_child(Node.string("lid", loc))
        pdata = Node.void("pdata")
        player.add_child(pdata)
        base = Node.void("base")
        pdata.add_child(base)
        base.add_child(Node.s32("uid", extid))
        base.add_child(Node.string("name", self.NAME))
        base.add_child(Node.s16("lv", 1))
        base.add_child(Node.s32("exp", 0))
        base.add_child(Node.s16("mg", 0))
        base.add_child(Node.s16("ap", 0))
        base.add_child(Node.s32("flag", 0))
        con = Node.void("con")
        pdata.add_child(con)
        con.add_child(Node.s32("day", 0))
        con.add_child(Node.s32("cnt", 0))
        con.add_child(Node.s32("last", 0))
        con.add_child(Node.s32("now", 0))
        custom = Node.void("custom")
        pdata.add_child(custom)
        custom.add_child(Node.u8("bgm_m", 0))
        custom.add_child(Node.u8("st_f", 0))
        custom.add_child(Node.u8("st_bg", 0))
        custom.add_child(Node.u8("st_bg_b", 100))
        custom.add_child(Node.u8("eff_e", 0))
        custom.add_child(Node.u8("se_s", 0))
        custom.add_child(Node.u8("se_s_v", 100))
        pdata.add_child(Node.void("released"))

        # First, filter down to only records that are also in the battle log
        def key(thing: Dict[str, int]) -> str:
            return f'{thing["id"]}-{thing["chart"]}'

        updates = [key(score) for score in scores]
        sortedrecords = {key(record): record for record in records if key(record) in updates}

        # Now, see what records need updating and update them
        for score in scores:
            if key(score) in sortedrecords:
                # Had a record, need to merge
                record = sortedrecords[key(score)]
            else:
                # First time playing
                record = {
                    "clear_type": 0,
                    "achievement_rate": 0,
                    "score": 0,
                    "combo": 0,
                    "miss_count": 999999999,
                }

            sortedrecords[key(score)] = {
                "id": score["id"],
                "chart": score["chart"],
                "clear_type": max(record["clear_type"], score["clear_type"]),
                "achievement_rate": max(record["achievement_rate"], score["achievement_rate"]),
                "score": max(record["score"], score["score"]),
                "combo": max(record["combo"], score["combo"]),
                "miss_count": min(record["miss_count"], score["miss_count"]),
            }

        # Finally, send the records and battle logs
        recordnode = Node.void("record")
        pdata.add_child(recordnode)
        blog = Node.void("blog")
        pdata.add_child(blog)

        for _, record in sortedrecords.items():
            rec = Node.void("rec")
            recordnode.add_child(rec)
            rec.add_child(Node.u16("mid", record["id"]))
            rec.add_child(Node.u8("ng", record["chart"]))
            rec.add_child(Node.s32("win", 1))
            rec.add_child(Node.s32("lose", 0))
            rec.add_child(Node.s32("draw", 0))
            rec.add_child(Node.u8("ct", record["clear_type"]))
            rec.add_child(Node.s16("ar", record["achievement_rate"]))
            rec.add_child(Node.s16("bs", record["score"]))
            rec.add_child(Node.s16("mc", record["combo"]))
            rec.add_child(Node.s16("bmc", record["miss_count"]))

        scoreid = 0
        for score in scores:
            log = Node.void("log")
            blog.add_child(log)
            log.add_child(Node.u8("id", scoreid))
            log.add_child(Node.u16("mid", score["id"]))
            log.add_child(Node.u8("ng", score["chart"]))
            log.add_child(Node.u8("mt", 0))
            log.add_child(Node.u8("rt", 0))
            log.add_child(Node.s32("ruid", 0))
            myself = Node.void("myself")
            log.add_child(myself)
            myself.add_child(Node.s16("mg", 0))
            myself.add_child(Node.s16("ap", 0))
            myself.add_child(Node.u8("ct", score["clear_type"]))
            myself.add_child(Node.s16("s", score["score"]))
            myself.add_child(Node.s16("ar", score["achievement_rate"]))
            rival = Node.void("rival")
            log.add_child(rival)
            rival.add_child(Node.s16("mg", 0))
            rival.add_child(Node.s16("ap", 0))
            rival.add_child(Node.u8("ct", 2))
            rival.add_child(Node.s16("s", 177))
            rival.add_child(Node.s16("ar", 500))
            log.add_child(Node.s32("time", Time.now()))
            scoreid = scoreid + 1

        # Swap with server
        resp = self.exchange("", call)

        # Verify that response is correct
        self.assert_path(resp, "response/player/uid")
        self.assert_path(resp, "response/player/time")
        return resp.child_value("player/uid")

    def verify_log_play(self, extid: int, loc: str, scores: List[Dict[str, int]]) -> None:
        call = self.call_node()

        log = Node.void("log")
        call.add_child(log)
        log.set_attribute("method", "play")
        log.add_child(Node.s32("uid", extid))
        log.add_child(Node.string("lid", loc))
        play = Node.void("play")
        log.add_child(play)
        play.add_child(Node.s16("stage", len(scores)))
        play.add_child(Node.s32("sec", 700))

        scoreid = 0
        for score in scores:
            rec = Node.void("rec")
            log.add_child(rec)
            rec.add_child(Node.s16("idx", scoreid))
            rec.add_child(Node.s16("mid", score["id"]))
            rec.add_child(Node.s16("grade", score["chart"]))
            rec.add_child(Node.s16("color", 0))
            rec.add_child(Node.s16("match", 0))
            rec.add_child(Node.s16("res", 0))
            rec.add_child(Node.s16("score", score["score"]))
            rec.add_child(Node.s16("mc", score["combo"]))
            rec.add_child(Node.s16("jt_jr", 0))
            rec.add_child(Node.s16("jt_ju", 0))
            rec.add_child(Node.s16("jt_gr", 0))
            rec.add_child(Node.s16("jt_gd", 0))
            rec.add_child(Node.s16("jt_ms", score["miss_count"]))
            rec.add_child(Node.s32("sec", 200))
            scoreid = scoreid + 1

        # Swap with server
        resp = self.exchange("", call)

        # Verify that response is correct
        self.assert_path(resp, "response/log/@status")

    def verify_lobby_read(self, location: str, extid: int) -> None:
        call = self.call_node()

        lobby = Node.void("lobby")
        lobby.set_attribute("method", "read")
        lobby.add_child(Node.s32("uid", extid))
        lobby.add_child(Node.u8("m_grade", 255))
        lobby.add_child(Node.string("lid", location))
        lobby.add_child(Node.s32("max", 128))
        call.add_child(lobby)

        # Swap with server
        resp = self.exchange("", call)

        # Verify that response is correct
        self.assert_path(resp, "response/lobby/@status")

    def verify_lobby_entry(self, location: str, extid: int) -> int:
        call = self.call_node()

        lobby = Node.void("lobby")
        lobby.set_attribute("method", "entry")
        e = Node.void("e")
        lobby.add_child(e)
        e.add_child(Node.s32("eid", 0))
        e.add_child(Node.u16("mid", 79))
        e.add_child(Node.u8("ng", 0))
        e.add_child(Node.s32("uid", extid))
        e.add_child(Node.string("pn", self.NAME))
        e.add_child(Node.s32("exp", 0))
        e.add_child(Node.u8("mg", 0))
        e.add_child(Node.s32("tid", 0))
        e.add_child(Node.string("tn", ""))
        e.add_child(Node.string("lid", location))
        e.add_child(Node.string("sn", ""))
        e.add_child(Node.u8("pref", 51))
        e.add_child(Node.u8_array("ga", [127, 0, 0, 1]))
        e.add_child(Node.u16("gp", 10007))
        e.add_child(Node.u8_array("la", [16, 0, 0, 0]))
        call.add_child(lobby)

        # Swap with server
        resp = self.exchange("", call)

        # Verify that response is correct
        self.assert_path(resp, "response/lobby/eid")
        self.assert_path(resp, "response/lobby/e/eid")
        self.assert_path(resp, "response/lobby/e/mid")
        self.assert_path(resp, "response/lobby/e/ng")
        self.assert_path(resp, "response/lobby/e/uid")
        self.assert_path(resp, "response/lobby/e/pn")
        self.assert_path(resp, "response/lobby/e/exp")
        self.assert_path(resp, "response/lobby/e/mg")
        self.assert_path(resp, "response/lobby/e/tid")
        self.assert_path(resp, "response/lobby/e/tn")
        self.assert_path(resp, "response/lobby/e/lid")
        self.assert_path(resp, "response/lobby/e/sn")
        self.assert_path(resp, "response/lobby/e/pref")
        self.assert_path(resp, "response/lobby/e/ga")
        self.assert_path(resp, "response/lobby/e/gp")
        self.assert_path(resp, "response/lobby/e/la")
        return resp.child_value("lobby/eid")

    def verify_lobby_delete(self, eid: int) -> None:
        call = self.call_node()

        lobby = Node.void("lobby")
        lobby.set_attribute("method", "delete")
        lobby.add_child(Node.s32("eid", eid))
        call.add_child(lobby)

        # Swap with server
        resp = self.exchange("", call)

        # Verify that response is correct
        self.assert_path(resp, "response/lobby")

    def verify(self, cardid: Optional[str]) -> None:
        # Verify boot sequence is okay
        self.verify_services_get(
            expected_services=[
                "pcbtracker",
                "pcbevent",
                "local",
                "message",
                "facility",
                "cardmng",
                "package",
                "posevent",
                "pkglist",
                "dlstatus",
                "eacoin",
                "lobby",
                "ntp",
                "keepalive",
            ]
        )
        paseli_enabled = self.verify_pcbtracker_alive()
        self.verify_message_get()
        self.verify_package_list()
        location = self.verify_facility_get()
        self.verify_pcbevent_put()

        self.verify_log_pcb_status(location)
        self.verify_pcbinfo_get(location)

        self.verify_sysinfo_get()
        self.verify_sysinfo_fan(location)

        # Verify card registration and profile lookup
        if cardid is not None:
            card = cardid
        else:
            card = self.random_card()
            print(f"Generated random card ID {card} for use.")

        if cardid is None:
            self.verify_cardmng_inquire(card, msg_type="unregistered", paseli_enabled=paseli_enabled)
            ref_id = self.verify_cardmng_getrefid(card)
            if len(ref_id) != 16:
                raise Exception(f"Invalid refid '{ref_id}' returned when registering card")
            if ref_id != self.verify_cardmng_inquire(card, msg_type="new", paseli_enabled=paseli_enabled):
                raise Exception(f"Invalid refid '{ref_id}' returned when querying card")
            # Always get a player start, regardless of new profile or not
            self.verify_player_start(ref_id)
            self.verify_player_delete(ref_id)
            extid = self.verify_player_write(
                ref_id,
                0,
                location,
                [],
                [],
            )
        else:
            print("Skipping new card checks for existing card")
            ref_id = self.verify_cardmng_inquire(card, msg_type="query", paseli_enabled=paseli_enabled)

        # Verify pin handling and return card handling
        self.verify_cardmng_authpass(ref_id, correct=True)
        self.verify_cardmng_authpass(ref_id, correct=False)
        if ref_id != self.verify_cardmng_inquire(card, msg_type="query", paseli_enabled=paseli_enabled):
            raise Exception(f"Invalid refid '{ref_id}' returned when querying card")

        # Verify lobby functionality
        self.verify_lobby_read(location, extid)
        eid = self.verify_lobby_entry(location, extid)
        self.verify_lobby_delete(eid)

        # Original reflec is weird and sends only the top record for each song you played,
        # and then a separate battle log. So, emulating that is kinda hard.
        scores: List[Dict[str, int]] = []
        if cardid is None:
            # Verify score saving and updating
            for phase in [1, 2]:
                if phase == 1:
                    dummyscores = [
                        # An okay score on a chart
                        {
                            "id": 1,
                            "chart": 1,
                            "clear_type": 2,
                            "achievement_rate": 7543,
                            "score": 432,
                            "combo": 123,
                            "miss_count": 5,
                        },
                        # A good score on an easier chart of the same song
                        {
                            "id": 1,
                            "chart": 0,
                            "clear_type": 3,
                            "achievement_rate": 9876,
                            "score": 543,
                            "combo": 543,
                            "miss_count": 0,
                        },
                        # A bad score on a hard chart
                        {
                            "id": 3,
                            "chart": 2,
                            "clear_type": 2,
                            "achievement_rate": 1234,
                            "score": 123,
                            "combo": 42,
                            "miss_count": 54,
                        },
                        # A terrible score on an easy chart
                        {
                            "id": 3,
                            "chart": 0,
                            "clear_type": 2,
                            "achievement_rate": 1024,
                            "score": 50,
                            "combo": 12,
                            "miss_count": 90,
                        },
                    ]
                if phase == 2:
                    dummyscores = [
                        # A better score on the same chart
                        {
                            "id": 1,
                            "chart": 1,
                            "clear_type": 3,
                            "achievement_rate": 8765,
                            "score": 469,
                            "combo": 468,
                            "miss_count": 1,
                        },
                        # A worse score on another same chart
                        {
                            "id": 1,
                            "chart": 0,
                            "clear_type": 2,
                            "achievement_rate": 8765,
                            "score": 432,
                            "combo": 321,
                            "miss_count": 15,
                            "expected_score": 543,
                            "expected_clear_type": 3,
                            "expected_achievement_rate": 9876,
                            "expected_combo": 543,
                            "expected_miss_count": 0,
                        },
                    ]
                self.verify_player_write(ref_id, extid, location, scores, dummyscores)
                self.verify_log_play(extid, location, dummyscores)

                scores = self.verify_player_read(ref_id, location)
                for expected in dummyscores:
                    actual = None
                    for received in scores:
                        if received["id"] == expected["id"] and received["chart"] == expected["chart"]:
                            actual = received
                            break

                    if actual is None:
                        raise Exception(f"Didn't find song {expected['id']} chart {expected['chart']} in response!")

                    if "expected_score" in expected:
                        expected_score = expected["expected_score"]
                    else:
                        expected_score = expected["score"]
                    if "expected_achievement_rate" in expected:
                        expected_achievement_rate = expected["expected_achievement_rate"]
                    else:
                        expected_achievement_rate = expected["achievement_rate"]
                    if "expected_clear_type" in expected:
                        expected_clear_type = expected["expected_clear_type"]
                    else:
                        expected_clear_type = expected["clear_type"]
                    if "expected_combo" in expected:
                        expected_combo = expected["expected_combo"]
                    else:
                        expected_combo = expected["combo"]
                    if "expected_miss_count" in expected:
                        expected_miss_count = expected["expected_miss_count"]
                    else:
                        expected_miss_count = expected["miss_count"]

                    if actual["score"] != expected_score:
                        raise Exception(
                            f'Expected a score of \'{expected_score}\' for song \'{expected["id"]}\' chart \'{expected["chart"]}\' but got score \'{actual["score"]}\''
                        )
                    if actual["achievement_rate"] != expected_achievement_rate:
                        raise Exception(
                            f'Expected an achievement rate of \'{expected_achievement_rate}\' for song \'{expected["id"]}\' chart \'{expected["chart"]}\' but got achievement rate \'{actual["achievement_rate"]}\''
                        )
                    if actual["clear_type"] != expected_clear_type:
                        raise Exception(
                            f'Expected a clear_type of \'{expected_clear_type}\' for song \'{expected["id"]}\' chart \'{expected["chart"]}\' but got clear_type \'{actual["clear_type"]}\''
                        )
                    if actual["combo"] != expected_combo:
                        raise Exception(
                            f'Expected a combo of \'{expected_combo}\' for song \'{expected["id"]}\' chart \'{expected["chart"]}\' but got combo \'{actual["combo"]}\''
                        )
                    if actual["miss_count"] != expected_miss_count:
                        raise Exception(
                            f'Expected a miss count of \'{expected_miss_count}\' for song \'{expected["id"]}\' chart \'{expected["chart"]}\' but got miss count \'{actual["miss_count"]}\''
                        )

                # Sleep so we don't end up putting in score history on the same second
                time.sleep(1)

        else:
            print("Skipping score checks for existing card")

        # Verify ending game
        self.verify_player_end(ref_id)

        # Verify paseli handling
        if paseli_enabled:
            print("PASELI enabled for this PCBID, executing PASELI checks")
        else:
            print("PASELI disabled for this PCBID, skipping PASELI checks")
            return

        sessid, balance = self.verify_eacoin_checkin(card)
        if balance == 0:
            print("Skipping PASELI consume check because card has 0 balance")
        else:
            self.verify_eacoin_consume(sessid, balance, random.randint(0, balance))
        self.verify_eacoin_checkout(sessid)