mirror of
https://github.com/DragonMinded/bemaniutils.git
synced 2026-09-27 01:10:26 +03:00
674 lines
26 KiB
Python
674 lines
26 KiB
Python
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)
|