1504 lines
65 KiB
Python
1504 lines
65 KiB
Python
from typing import Optional, Dict, Any, List, Tuple
|
||
from typing_extensions import Final
|
||
|
||
from bemani.backend.reflec.base import ReflecBeatBase
|
||
from bemani.backend.reflec.colette import ReflecBeatColette
|
||
|
||
from bemani.common import Profile, ValidatedDict, VersionConstants, ID, Time
|
||
from bemani.data import Achievement, Attempt, Score, UserID
|
||
from bemani.protocol import Node
|
||
|
||
|
||
class ReflecBeatGroovin(ReflecBeatBase):
|
||
|
||
name: str = "REFLEC BEAT groovin'!!"
|
||
version: int = VersionConstants.REFLEC_BEAT_GROOVIN
|
||
|
||
# Clear types according to the game
|
||
GAME_CLEAR_TYPE_NO_PLAY: Final[int] = 0
|
||
GAME_CLEAR_TYPE_EARLY_FAILED: Final[int] = 1
|
||
GAME_CLEAR_TYPE_FAILED: Final[int] = 2
|
||
GAME_CLEAR_TYPE_CLEARED: Final[int] = 9
|
||
GAME_CLEAR_TYPE_HARD_CLEARED: Final[int] = 10
|
||
GAME_CLEAR_TYPE_S_HARD_CLEARED: Final[int] = 11
|
||
|
||
# Combo types according to the game (actually a bitmask, where bit 0 is
|
||
# full combo status, and bit 2 is just reflec status). But we don't support
|
||
# saving just reflec without full combo, so we downgrade it.
|
||
GAME_COMBO_TYPE_NONE: Final[int] = 0
|
||
GAME_COMBO_TYPE_ALL_JUST: Final[int] = 2
|
||
GAME_COMBO_TYPE_FULL_COMBO: Final[int] = 1
|
||
GAME_COMBO_TYPE_FULL_COMBO_ALL_JUST: Final[int] = 3
|
||
|
||
def previous_version(self) -> Optional[ReflecBeatBase]:
|
||
return ReflecBeatColette(self.data, self.config, self.model)
|
||
|
||
@classmethod
|
||
def get_settings(cls) -> Dict[str, Any]:
|
||
"""
|
||
Return all of our front-end modifiably settings.
|
||
"""
|
||
return {
|
||
'bools': [
|
||
{
|
||
'name': 'Force Song Unlock',
|
||
'tip': 'Force unlock all songs.',
|
||
'category': 'game_config',
|
||
'setting': 'force_unlock_songs',
|
||
},
|
||
],
|
||
'ints': [],
|
||
}
|
||
|
||
def __db_to_game_clear_type(self, db_status: int) -> int:
|
||
return {
|
||
self.CLEAR_TYPE_NO_PLAY: self.GAME_CLEAR_TYPE_NO_PLAY,
|
||
self.CLEAR_TYPE_FAILED: self.GAME_CLEAR_TYPE_FAILED,
|
||
self.CLEAR_TYPE_CLEARED: self.GAME_CLEAR_TYPE_CLEARED,
|
||
self.CLEAR_TYPE_HARD_CLEARED: self.GAME_CLEAR_TYPE_HARD_CLEARED,
|
||
self.CLEAR_TYPE_S_HARD_CLEARED: self.GAME_CLEAR_TYPE_S_HARD_CLEARED,
|
||
}[db_status]
|
||
|
||
def __game_to_db_clear_type(self, status: int) -> int:
|
||
return {
|
||
self.GAME_CLEAR_TYPE_NO_PLAY: self.CLEAR_TYPE_NO_PLAY,
|
||
self.GAME_CLEAR_TYPE_EARLY_FAILED: self.CLEAR_TYPE_FAILED,
|
||
self.GAME_CLEAR_TYPE_FAILED: self.CLEAR_TYPE_FAILED,
|
||
self.GAME_CLEAR_TYPE_CLEARED: self.CLEAR_TYPE_CLEARED,
|
||
self.GAME_CLEAR_TYPE_HARD_CLEARED: self.CLEAR_TYPE_HARD_CLEARED,
|
||
self.GAME_CLEAR_TYPE_S_HARD_CLEARED: self.CLEAR_TYPE_S_HARD_CLEARED,
|
||
}[status]
|
||
|
||
def __db_to_game_combo_type(self, db_combo: int) -> int:
|
||
return {
|
||
self.COMBO_TYPE_NONE: self.GAME_COMBO_TYPE_NONE,
|
||
self.COMBO_TYPE_ALMOST_COMBO: self.GAME_COMBO_TYPE_NONE,
|
||
self.COMBO_TYPE_FULL_COMBO: self.GAME_COMBO_TYPE_FULL_COMBO,
|
||
self.COMBO_TYPE_FULL_COMBO_ALL_JUST: self.GAME_COMBO_TYPE_FULL_COMBO_ALL_JUST,
|
||
}[db_combo]
|
||
|
||
def __game_to_db_combo_type(self, game_combo: int, miss_count: int) -> int:
|
||
if game_combo in [
|
||
self.GAME_COMBO_TYPE_NONE,
|
||
self.GAME_COMBO_TYPE_ALL_JUST,
|
||
]:
|
||
if miss_count >= 0 and miss_count <= 2:
|
||
return self.COMBO_TYPE_ALMOST_COMBO
|
||
else:
|
||
return self.COMBO_TYPE_NONE
|
||
if game_combo == self.GAME_COMBO_TYPE_FULL_COMBO:
|
||
return self.COMBO_TYPE_FULL_COMBO
|
||
if game_combo == self.GAME_COMBO_TYPE_FULL_COMBO_ALL_JUST:
|
||
return self.COMBO_TYPE_FULL_COMBO_ALL_JUST
|
||
raise Exception(f'Invalid game_combo value {game_combo}')
|
||
|
||
def handle_pcb_rb4error_request(self, request: Node) -> Node:
|
||
return Node.void('pcb')
|
||
|
||
def handle_pcb_rb4uptime_update_request(self, request: Node) -> Node:
|
||
return Node.void('pcb')
|
||
|
||
def handle_pcb_rb4boot_request(self, request: Node) -> Node:
|
||
shop_id = ID.parse_machine_id(request.child_value('lid'))
|
||
machine = self.get_machine_by_id(shop_id)
|
||
if machine is not None:
|
||
machine_name = machine.name
|
||
close = machine.data.get_bool('close')
|
||
hour = machine.data.get_int('hour')
|
||
minute = machine.data.get_int('minute')
|
||
else:
|
||
machine_name = ''
|
||
close = False
|
||
hour = 0
|
||
minute = 0
|
||
|
||
root = Node.void('pcb')
|
||
sinfo = Node.void('sinfo')
|
||
root.add_child(sinfo)
|
||
sinfo.add_child(Node.string('nm', machine_name))
|
||
sinfo.add_child(Node.bool('cl_enbl', close))
|
||
sinfo.add_child(Node.u8('cl_h', hour))
|
||
sinfo.add_child(Node.u8('cl_m', minute))
|
||
sinfo.add_child(Node.bool('shop_flag', True))
|
||
return root
|
||
|
||
def handle_lobby_rb4entry_request(self, request: Node) -> Node:
|
||
root = Node.void('lobby')
|
||
root.add_child(Node.s32('interval', 120))
|
||
root.add_child(Node.s32('interval_p', 120))
|
||
|
||
# Create a lobby entry for this user
|
||
extid = request.child_value('e/uid')
|
||
userid = self.data.remote.user.from_extid(self.game, self.version, extid)
|
||
if userid is not None:
|
||
profile = self.get_profile(userid)
|
||
info = self.data.local.lobby.get_play_session_info(self.game, self.version, userid)
|
||
if profile is None or info is None:
|
||
return root
|
||
|
||
self.data.local.lobby.put_lobby(
|
||
self.game,
|
||
self.version,
|
||
userid,
|
||
{
|
||
'mid': request.child_value('e/mid'),
|
||
'ng': request.child_value('e/ng'),
|
||
'mopt': request.child_value('e/mopt'),
|
||
'lid': request.child_value('e/lid'),
|
||
'sn': request.child_value('e/sn'),
|
||
'pref': request.child_value('e/pref'),
|
||
'stg': request.child_value('e/stg'),
|
||
'pside': request.child_value('e/pside'),
|
||
'eatime': request.child_value('e/eatime'),
|
||
'ga': request.child_value('e/ga'),
|
||
'gp': request.child_value('e/gp'),
|
||
'la': request.child_value('e/la'),
|
||
'ver': request.child_value('e/ver'),
|
||
'tension': request.child_value('e/tension'),
|
||
}
|
||
)
|
||
lobby = self.data.local.lobby.get_lobby(
|
||
self.game,
|
||
self.version,
|
||
userid,
|
||
)
|
||
root.add_child(Node.s32('eid', lobby.get_int('id')))
|
||
e = Node.void('e')
|
||
root.add_child(e)
|
||
e.add_child(Node.s32('eid', lobby.get_int('id')))
|
||
e.add_child(Node.u16('mid', lobby.get_int('mid')))
|
||
e.add_child(Node.u8('ng', lobby.get_int('ng')))
|
||
e.add_child(Node.s32('uid', profile.extid))
|
||
e.add_child(Node.s32('uattr', profile.get_int('uattr')))
|
||
e.add_child(Node.string('pn', profile.get_str('name')))
|
||
e.add_child(Node.s32('plyid', info.get_int('id')))
|
||
e.add_child(Node.s16('mg', profile.get_int('mg')))
|
||
e.add_child(Node.s32('mopt', lobby.get_int('mopt')))
|
||
e.add_child(Node.string('lid', lobby.get_str('lid')))
|
||
e.add_child(Node.string('sn', lobby.get_str('sn')))
|
||
e.add_child(Node.u8('pref', lobby.get_int('pref')))
|
||
e.add_child(Node.s8('stg', lobby.get_int('stg')))
|
||
e.add_child(Node.s8('pside', lobby.get_int('pside')))
|
||
e.add_child(Node.s16('eatime', lobby.get_int('eatime')))
|
||
e.add_child(Node.u8_array('ga', lobby.get_int_array('ga', 4)))
|
||
e.add_child(Node.u16('gp', lobby.get_int('gp')))
|
||
e.add_child(Node.u8_array('la', lobby.get_int_array('la', 4)))
|
||
e.add_child(Node.u8('ver', lobby.get_int('ver')))
|
||
e.add_child(Node.s8('tension', lobby.get_int('tension')))
|
||
|
||
return root
|
||
|
||
def handle_lobby_rb4read_request(self, request: Node) -> Node:
|
||
root = Node.void('lobby')
|
||
root.add_child(Node.s32('interval', 120))
|
||
root.add_child(Node.s32('interval_p', 120))
|
||
|
||
# Look up all lobbies matching the criteria specified
|
||
ver = request.child_value('var')
|
||
mg = request.child_value('m_grade') # noqa: F841
|
||
extid = request.child_value('uid')
|
||
limit = request.child_value('max')
|
||
userid = self.data.remote.user.from_extid(self.game, self.version, extid)
|
||
if userid is not None:
|
||
lobbies = self.data.local.lobby.get_all_lobbies(self.game, self.version)
|
||
for (user, lobby) in lobbies:
|
||
if limit <= 0:
|
||
break
|
||
|
||
if user == userid:
|
||
# If we have our own lobby, don't return it
|
||
continue
|
||
if ver != lobby.get_int('ver'):
|
||
# Don't return lobby data for different versions
|
||
continue
|
||
|
||
profile = self.get_profile(user)
|
||
info = self.data.local.lobby.get_play_session_info(self.game, self.version, userid)
|
||
if profile is None or info is None:
|
||
# No profile info, don't return this lobby
|
||
return root
|
||
|
||
e = Node.void('e')
|
||
root.add_child(e)
|
||
e.add_child(Node.s32('eid', lobby.get_int('id')))
|
||
e.add_child(Node.u16('mid', lobby.get_int('mid')))
|
||
e.add_child(Node.u8('ng', lobby.get_int('ng')))
|
||
e.add_child(Node.s32('uid', profile.extid))
|
||
e.add_child(Node.s32('uattr', profile.get_int('uattr')))
|
||
e.add_child(Node.string('pn', profile.get_str('name')))
|
||
e.add_child(Node.s32('plyid', info.get_int('id')))
|
||
e.add_child(Node.s16('mg', profile.get_int('mg')))
|
||
e.add_child(Node.s32('mopt', lobby.get_int('mopt')))
|
||
e.add_child(Node.string('lid', lobby.get_str('lid')))
|
||
e.add_child(Node.string('sn', lobby.get_str('sn')))
|
||
e.add_child(Node.u8('pref', lobby.get_int('pref')))
|
||
e.add_child(Node.s8('stg', lobby.get_int('stg')))
|
||
e.add_child(Node.s8('pside', lobby.get_int('pside')))
|
||
e.add_child(Node.s16('eatime', lobby.get_int('eatime')))
|
||
e.add_child(Node.u8_array('ga', lobby.get_int_array('ga', 4)))
|
||
e.add_child(Node.u16('gp', lobby.get_int('gp')))
|
||
e.add_child(Node.u8_array('la', lobby.get_int_array('la', 4)))
|
||
e.add_child(Node.u8('ver', lobby.get_int('ver')))
|
||
e.add_child(Node.s8('tension', lobby.get_int('tension')))
|
||
|
||
limit = limit - 1
|
||
|
||
return root
|
||
|
||
def handle_lobby_rb4delete_request(self, request: Node) -> Node:
|
||
eid = request.child_value('eid')
|
||
self.data.local.lobby.destroy_lobby(eid)
|
||
return Node.void('lobby')
|
||
|
||
def handle_shop_rb4setting_write_request(self, request: Node) -> Node:
|
||
return Node.void('shop')
|
||
|
||
def handle_shop_rb4info_write_request(self, request: Node) -> Node:
|
||
self.update_machine_name(request.child_value('sinfo/nm'))
|
||
self.update_machine_data({
|
||
'close': request.child_value('sinfo/cl_enbl'),
|
||
'hour': request.child_value('sinfo/cl_h'),
|
||
'minute': request.child_value('sinfo/cl_m'),
|
||
'pref': request.child_value('sinfo/prf'),
|
||
})
|
||
return Node.void('shop')
|
||
|
||
def __add_event_info(self, root: Node) -> None:
|
||
event_ctrl = Node.void('event_ctrl')
|
||
root.add_child(event_ctrl)
|
||
# Contains zero or more nodes like:
|
||
# <data>
|
||
# <type __type="s32">any</type>
|
||
# <index __type="s32">any</phase>
|
||
# <value __type="s32">any</phase>
|
||
# <value2 __type="s32">any</phase>
|
||
# <start_time __type="s32">any</phase>
|
||
# <end_time __type="s32">any</phase>
|
||
# </data>
|
||
|
||
item_lock_ctrl = Node.void('item_lock_ctrl')
|
||
root.add_child(item_lock_ctrl)
|
||
# Contains zero or more nodes like:
|
||
# <item>
|
||
# <type __type="u8">any</type>
|
||
# <id __type="u16">any</id>
|
||
# <param __type="u16">0-3</param>
|
||
# </item>
|
||
|
||
def __add_shop_score(self, root: Node) -> None:
|
||
shop_score = Node.void('shop_score')
|
||
root.add_child(shop_score)
|
||
today = Node.void('today')
|
||
shop_score.add_child(today)
|
||
yesterday = Node.void('yesterday')
|
||
shop_score.add_child(yesterday)
|
||
|
||
all_profiles = self.data.local.user.get_all_profiles(self.game, self.version)
|
||
all_attempts = self.data.local.music.get_all_attempts(self.game, self.version, timelimit=(Time.beginning_of_today() - Time.SECONDS_IN_DAY))
|
||
machine = self.data.local.machine.get_machine(self.config.machine.pcbid)
|
||
if machine.arcade is not None:
|
||
lids = [
|
||
machine.id for machine in self.data.local.machine.get_all_machines(machine.arcade)
|
||
]
|
||
else:
|
||
lids = [machine.id]
|
||
|
||
relevant_profiles = [
|
||
profile for profile in all_profiles
|
||
if profile[1].get_int('lid', -1) in lids
|
||
]
|
||
|
||
for (rootnode, timeoffset) in [
|
||
(today, 0),
|
||
(yesterday, Time.SECONDS_IN_DAY),
|
||
]:
|
||
# Grab all attempts made in the relevant day
|
||
relevant_attempts = [
|
||
attempt for attempt in all_attempts
|
||
if (
|
||
attempt[1].timestamp >= (Time.beginning_of_today() - timeoffset) and
|
||
attempt[1].timestamp <= (Time.end_of_today() - timeoffset)
|
||
)
|
||
]
|
||
|
||
# Calculate scores based on attempt
|
||
scores_by_user: Dict[UserID, Dict[int, Dict[int, Attempt]]] = {}
|
||
for (userid, attempt) in relevant_attempts:
|
||
if userid not in scores_by_user:
|
||
scores_by_user[userid] = {}
|
||
if attempt.id not in scores_by_user[userid]:
|
||
scores_by_user[userid][attempt.id] = {}
|
||
if attempt.chart not in scores_by_user[userid][attempt.id]:
|
||
# No high score for this yet, just use this attempt
|
||
scores_by_user[userid][attempt.id][attempt.chart] = attempt
|
||
else:
|
||
# If this attempt is better than the stored one, replace it
|
||
if scores_by_user[userid][attempt.id][attempt.chart].points < attempt.points:
|
||
scores_by_user[userid][attempt.id][attempt.chart] = attempt
|
||
|
||
# Calculate points earned by user in the day
|
||
points_by_user: Dict[UserID, int] = {}
|
||
for userid in scores_by_user:
|
||
points_by_user[userid] = 0
|
||
for mid in scores_by_user[userid]:
|
||
for chart in scores_by_user[userid][mid]:
|
||
points_by_user[userid] = points_by_user[userid] + scores_by_user[userid][mid][chart].points
|
||
|
||
# Output that day's earned points
|
||
for (userid, profile) in relevant_profiles:
|
||
data = Node.void('data')
|
||
rootnode.add_child(data)
|
||
data.add_child(Node.s16('day_id', int((Time.now() - timeoffset) / Time.SECONDS_IN_DAY)))
|
||
data.add_child(Node.s32('user_id', profile.extid))
|
||
data.add_child(Node.s16('icon_id', profile.get_dict('config').get_int('icon_id')))
|
||
data.add_child(Node.s16('point', min(points_by_user.get(userid, 0), 32767)))
|
||
data.add_child(Node.s32('update_time', Time.now()))
|
||
data.add_child(Node.string('name', profile.get_str('name')))
|
||
|
||
rootnode.add_child(Node.s32('timestamp', Time.beginning_of_today() - timeoffset))
|
||
|
||
def handle_info_rb4common_request(self, request: Node) -> Node:
|
||
root = Node.void('info')
|
||
self.__add_event_info(root)
|
||
self.__add_shop_score(root)
|
||
|
||
return root
|
||
|
||
def handle_info_rb4ranking_request(self, request: Node) -> Node:
|
||
version = request.child_value('ver')
|
||
|
||
root = Node.void('info')
|
||
root.add_child(Node.s32('ver', version))
|
||
ranking = Node.void('ranking')
|
||
root.add_child(ranking)
|
||
|
||
def add_hitchart(name: str, start: int, end: int, hitchart: List[Tuple[int, int]]) -> None:
|
||
base = Node.void(name)
|
||
ranking.add_child(base)
|
||
base.add_child(Node.s32('bt', start))
|
||
base.add_child(Node.s32('et', end))
|
||
new = Node.void('new')
|
||
base.add_child(new)
|
||
|
||
for (mid, plays) in hitchart:
|
||
d = Node.void('d')
|
||
new.add_child(d)
|
||
d.add_child(Node.s16('mid', mid))
|
||
d.add_child(Node.s32('cnt', plays))
|
||
|
||
# Weekly hit chart
|
||
add_hitchart(
|
||
'weekly',
|
||
Time.now() - Time.SECONDS_IN_WEEK,
|
||
Time.now(),
|
||
self.data.local.music.get_hit_chart(self.game, self.version, 1024, 7),
|
||
)
|
||
|
||
# Monthly hit chart
|
||
add_hitchart(
|
||
'monthly',
|
||
Time.now() - Time.SECONDS_IN_DAY * 30,
|
||
Time.now(),
|
||
self.data.local.music.get_hit_chart(self.game, self.version, 1024, 30),
|
||
)
|
||
|
||
# All time hit chart
|
||
add_hitchart(
|
||
'total',
|
||
Time.now() - Time.SECONDS_IN_DAY * 365,
|
||
Time.now(),
|
||
self.data.local.music.get_hit_chart(self.game, self.version, 1024, 365),
|
||
)
|
||
|
||
return root
|
||
|
||
def handle_info_rb4shop_score_ranking_request(self, request: Node) -> Node:
|
||
start_music_id = request.child_value('min')
|
||
end_music_id = request.child_value('max')
|
||
|
||
root = Node.void('info')
|
||
shop_score = Node.void('shop_score')
|
||
root.add_child(shop_score)
|
||
shop_score.add_child(Node.s32('time', Time.now()))
|
||
|
||
profiles: Dict[UserID, Profile] = {}
|
||
for songid in range(start_music_id, end_music_id + 1):
|
||
allscores = self.data.local.music.get_all_scores(
|
||
self.game,
|
||
self.version,
|
||
songid=songid,
|
||
)
|
||
|
||
for ng in [
|
||
self.CHART_TYPE_BASIC,
|
||
self.CHART_TYPE_MEDIUM,
|
||
self.CHART_TYPE_HARD,
|
||
self.CHART_TYPE_SPECIAL,
|
||
]:
|
||
scores = sorted(
|
||
[score for score in allscores if score[1].chart == ng],
|
||
key=lambda score: score[1].points,
|
||
reverse=True,
|
||
)
|
||
|
||
for i in range(len(scores)):
|
||
userid, score = scores[i]
|
||
if userid not in profiles:
|
||
profiles[userid] = self.get_any_profile(userid)
|
||
profile = profiles[userid]
|
||
|
||
data = Node.void('data')
|
||
shop_score.add_child(data)
|
||
data.add_child(Node.s32('rank', i + 1))
|
||
data.add_child(Node.s16('music_id', songid))
|
||
data.add_child(Node.s8('note_grade', score.chart))
|
||
data.add_child(Node.s8('clear_type', self.__db_to_game_clear_type(score.data.get_int('clear_type'))))
|
||
data.add_child(Node.s32('user_id', profile.extid))
|
||
data.add_child(Node.s16('icon_id', profile.get_dict('config').get_int('icon_id')))
|
||
data.add_child(Node.s32('score', score.points))
|
||
data.add_child(Node.s32('time', score.timestamp))
|
||
data.add_child(Node.string('name', profile.get_str('name')))
|
||
|
||
return root
|
||
|
||
def handle_info_rb4pzlcmt_read_request(self, request: Node) -> Node:
|
||
extid = request.child_value('uid')
|
||
locid = ID.parse_machine_id(request.child_value('lid'))
|
||
limit = request.child_value('limit')
|
||
userid = self.data.remote.user.from_extid(self.game, self.version, extid)
|
||
|
||
comments = [
|
||
achievement for achievement in
|
||
self.data.local.user.get_all_time_based_achievements(self.game, self.version)
|
||
if achievement[1].type == 'puzzle_comment'
|
||
]
|
||
comments.sort(key=lambda x: x[1].timestamp, reverse=True)
|
||
favorites = [
|
||
comment for comment in comments
|
||
if comment[0] == userid
|
||
]
|
||
locationcomments = [
|
||
comment for comment in comments
|
||
if comment[1].data.get_int('locid') == locid
|
||
]
|
||
|
||
# Cap all comment blocks to the limit
|
||
if limit >= 0:
|
||
comments = comments[:limit]
|
||
favorites = favorites[:limit]
|
||
locationcomments = locationcomments[:limit]
|
||
|
||
root = Node.void('info')
|
||
comment = Node.void('comment')
|
||
root.add_child(comment)
|
||
comment.add_child(Node.s32('time', Time.now()))
|
||
|
||
# Mapping of profiles to userIDs
|
||
uid_mapping = {
|
||
uid: prof for (uid, prof) in self.get_any_profiles([c[0] for c in comments])
|
||
}
|
||
|
||
# Handle anonymous comments by returning a default profile
|
||
uid_mapping[UserID(0)] = Profile(
|
||
self.game,
|
||
self.version,
|
||
"",
|
||
0,
|
||
{'name': 'ＰＬＡＹＥＲ'},
|
||
)
|
||
|
||
def add_comments(name: str, selected: List[Tuple[UserID, Achievement]]) -> None:
|
||
for (uid, ach) in selected:
|
||
cmnt = Node.void(name)
|
||
root.add_child(cmnt)
|
||
cmnt.add_child(Node.s32('uid', uid_mapping[uid].extid))
|
||
cmnt.add_child(Node.string('name', uid_mapping[uid].get_str('name')))
|
||
cmnt.add_child(Node.s16('icon', ach.data.get_int('icon')))
|
||
cmnt.add_child(Node.s8('bln', ach.data.get_int('bln')))
|
||
cmnt.add_child(Node.string('lid', ID.format_machine_id(ach.data.get_int('locid'))))
|
||
cmnt.add_child(Node.s8('pref', ach.data.get_int('prefecture')))
|
||
cmnt.add_child(Node.s32('time', ach.timestamp))
|
||
cmnt.add_child(Node.string('comment', ach.data.get_str('comment')))
|
||
cmnt.add_child(Node.bool('is_tweet', ach.data.get_bool('tweet')))
|
||
|
||
# Add all comments
|
||
add_comments('c', comments)
|
||
|
||
# Add personal comments (favorites)
|
||
add_comments('cf', favorites)
|
||
|
||
# Add location comments
|
||
add_comments('cs', locationcomments)
|
||
|
||
return root
|
||
|
||
def handle_info_rb4pzlcmt_write_request(self, request: Node) -> Node:
|
||
extid = request.child_value('uid')
|
||
userid = self.data.remote.user.from_extid(self.game, self.version, extid)
|
||
if userid is None:
|
||
# Anonymous comment
|
||
userid = UserID(0)
|
||
|
||
icon = request.child_value('icon')
|
||
bln = request.child_value('bln')
|
||
locid = ID.parse_machine_id(request.child_value('lid'))
|
||
prefecture = request.child_value('pref')
|
||
comment = request.child_value('comment')
|
||
is_tweet = request.child_value('is_tweet')
|
||
|
||
# Link comment to user's profile
|
||
self.data.local.user.put_time_based_achievement(
|
||
self.game,
|
||
self.version,
|
||
userid,
|
||
0, # We never have an ID for this, since comments are add-only
|
||
'puzzle_comment',
|
||
{
|
||
'icon': icon,
|
||
'bln': bln,
|
||
'locid': locid,
|
||
'prefecture': prefecture,
|
||
'comment': comment,
|
||
'tweet': is_tweet,
|
||
},
|
||
)
|
||
|
||
return Node.void('info')
|
||
|
||
def handle_player_rb4start_request(self, request: Node) -> Node:
|
||
root = Node.void('player')
|
||
|
||
# Create a new play session based on info from the request
|
||
refid = request.child_value('rid')
|
||
userid = self.data.remote.user.from_refid(self.game, self.version, refid)
|
||
if userid is not None:
|
||
self.data.local.lobby.put_play_session_info(
|
||
self.game,
|
||
self.version,
|
||
userid,
|
||
{
|
||
'ga': request.child_value('ga'),
|
||
'gp': request.child_value('gp'),
|
||
'la': request.child_value('la'),
|
||
'pnid': request.child_value('pnid'),
|
||
},
|
||
)
|
||
info = self.data.local.lobby.get_play_session_info(
|
||
self.game,
|
||
self.version,
|
||
userid,
|
||
)
|
||
if info is not None:
|
||
play_id = info.get_int('id')
|
||
else:
|
||
play_id = 0
|
||
else:
|
||
play_id = 0
|
||
|
||
# Session stuff, and resend global defaults
|
||
root.add_child(Node.s32('plyid', play_id))
|
||
root.add_child(Node.u64('start_time', Time.now() * 1000))
|
||
self.__add_event_info(root)
|
||
|
||
return root
|
||
|
||
def handle_player_rb4end_request(self, request: Node) -> Node:
|
||
# Destroy play session based on info from the request
|
||
refid = request.child_value('rid')
|
||
userid = self.data.remote.user.from_refid(self.game, self.version, refid)
|
||
if userid is not None:
|
||
# Kill any lingering lobbies by this user
|
||
lobby = self.data.local.lobby.get_lobby(
|
||
self.game,
|
||
self.version,
|
||
userid,
|
||
)
|
||
if lobby is not None:
|
||
self.data.local.lobby.destroy_lobby(lobby.get_int('id'))
|
||
self.data.local.lobby.destroy_play_session_info(self.game, self.version, userid)
|
||
|
||
return Node.void('player')
|
||
|
||
def handle_player_rb4readepisode_request(self, request: Node) -> Node:
|
||
extid = request.child_value('user_id')
|
||
userid = self.data.remote.user.from_extid(self.game, self.version, extid)
|
||
if userid is not None:
|
||
achievements = self.data.local.user.get_achievements(self.game, self.version, userid)
|
||
else:
|
||
achievements = []
|
||
|
||
root = Node.void('player')
|
||
pdata = Node.void('pdata')
|
||
root.add_child(pdata)
|
||
episode = Node.void('episode')
|
||
pdata.add_child(episode)
|
||
|
||
for achievement in achievements:
|
||
if achievement.type != 'episode':
|
||
continue
|
||
|
||
info = Node.void('info')
|
||
episode.add_child(info)
|
||
info.add_child(Node.s32('user_id', extid))
|
||
info.add_child(Node.u8('type', achievement.id))
|
||
info.add_child(Node.u16('value0', achievement.data.get_int('value0')))
|
||
info.add_child(Node.u16('value1', achievement.data.get_int('value1')))
|
||
info.add_child(Node.string('text', achievement.data.get_str('text')))
|
||
info.add_child(Node.s32('time', achievement.data.get_int('time')))
|
||
|
||
return root
|
||
|
||
def handle_player_rb4readscore_request(self, request: Node) -> Node:
|
||
refid = request.child_value('rid')
|
||
userid = self.data.remote.user.from_refid(self.game, self.version, refid)
|
||
if userid is None:
|
||
scores: List[Score] = []
|
||
else:
|
||
scores = self.data.remote.music.get_scores(self.game, self.version, userid)
|
||
|
||
root = Node.void('player')
|
||
pdata = Node.void('pdata')
|
||
root.add_child(pdata)
|
||
|
||
record = Node.void('record')
|
||
pdata.add_child(record)
|
||
record_old = Node.void('record_old')
|
||
pdata.add_child(record_old)
|
||
|
||
for score in scores:
|
||
rec = Node.void('rec')
|
||
record.add_child(rec)
|
||
rec.add_child(Node.s16('mid', score.id))
|
||
rec.add_child(Node.s8('ntgrd', score.chart))
|
||
rec.add_child(Node.s32('pc', score.plays))
|
||
rec.add_child(Node.s8('ct', self.__db_to_game_clear_type(score.data.get_int('clear_type'))))
|
||
rec.add_child(Node.s16('ar', score.data.get_int('achievement_rate')))
|
||
rec.add_child(Node.s16('scr', score.points))
|
||
rec.add_child(Node.s16('ms', score.data.get_int('miss_count')))
|
||
rec.add_child(Node.s16(
|
||
'param',
|
||
self.__db_to_game_combo_type(score.data.get_int('combo_type')) + score.data.get_int('param'),
|
||
))
|
||
rec.add_child(Node.s32('bscrt', score.timestamp))
|
||
rec.add_child(Node.s32('bart', score.data.get_int('best_achievement_rate_time')))
|
||
rec.add_child(Node.s32('bctt', score.data.get_int('best_clear_type_time')))
|
||
rec.add_child(Node.s32('bmst', score.data.get_int('best_miss_count_time')))
|
||
rec.add_child(Node.s32('time', score.data.get_int('last_played_time')))
|
||
|
||
return root
|
||
|
||
def handle_player_rb4selectscore_request(self, request: Node) -> Node:
|
||
extid = request.child_value('uid')
|
||
songid = request.child_value('music_id')
|
||
chart = request.child_value('note_grade')
|
||
userid = self.data.remote.user.from_extid(self.game, self.version, extid)
|
||
if userid is None:
|
||
score = None
|
||
profile = None
|
||
else:
|
||
score = self.data.remote.music.get_score(self.game, self.version, userid, songid, chart)
|
||
profile = self.get_any_profile(userid)
|
||
|
||
root = Node.void('player')
|
||
if score is not None and profile is not None:
|
||
player_select_score = Node.void('player_select_score')
|
||
root.add_child(player_select_score)
|
||
|
||
player_select_score.add_child(Node.s32('user_id', extid))
|
||
player_select_score.add_child(Node.string('name', profile.get_str('name')))
|
||
player_select_score.add_child(Node.s32('m_score', score.points))
|
||
player_select_score.add_child(Node.s32('m_scoreTime', score.timestamp))
|
||
player_select_score.add_child(Node.s16('m_iconID', profile.get_dict('config').get_int('icon_id')))
|
||
return root
|
||
|
||
def handle_player_rbsvLinkageSave_request(self, request: Node) -> Node:
|
||
# I think this is ReflecBeat/SoundVoltex linkage save, and I
|
||
# am somewhat convinced that PK/BN is for packets/blocks, but
|
||
# whatever.
|
||
root = Node.void('player')
|
||
root.add_child(Node.s32('before_pk_value', -1))
|
||
root.add_child(Node.s32('after_pk_value', -1))
|
||
root.add_child(Node.s32('before_bn_value', -1))
|
||
root.add_child(Node.s32('after_bn_value', -1))
|
||
return root
|
||
|
||
def handle_player_rb4total_bestallrank_read_request(self, request: Node) -> Node:
|
||
# This gives us a 6-integer array mapping to user scores for the following:
|
||
# [total score, basic chart score, medium chart score, hard chart score,
|
||
# special chart score, new songs score].
|
||
# It appears to return several 6-array values similar to the following:
|
||
# <score>
|
||
# <rank __type="s32" __count="6">1 2 3 4 5 6</rank>
|
||
# <score __type="s32" __count="6">101 102 103 104 105 106</score>
|
||
# <allrank __type="s32" __count="6">7 8 9 10 11 12</allrank>
|
||
# </score>
|
||
# The first 'rank' is the displayed value for the six categories. The
|
||
# second and third values appear unused in-game. I think this is supposed
|
||
# to give a player the idea of what ranking they are on the server for
|
||
# various scores.
|
||
current_scores = request.child_value('score')
|
||
|
||
# First, grab all scores on the network for this version, and all songs
|
||
# available so we know which songs are new to this version of the game.
|
||
all_scores = self.data.remote.music.get_all_scores(self.game, self.version)
|
||
all_songs = self.data.local.music.get_all_songs(self.game, self.version)
|
||
|
||
# Figure out what song IDs are new
|
||
new_songs = {song.id for song in all_songs if song.data.get_int('folder', 0) == self.version}
|
||
|
||
# Now grab all participating users that had scores
|
||
all_users = {userid for (userid, score) in all_scores}
|
||
|
||
# Now, group the scores by user, so we can add up the totals, only including
|
||
# scores where the user at least cleared the song.
|
||
scores_by_user = {
|
||
userid: [
|
||
score for (uid, score) in all_scores
|
||
if uid == userid and score.data.get_int('clear_type') >= self.CLEAR_TYPE_CLEARED]
|
||
for userid in all_users
|
||
}
|
||
|
||
# Now, sum up the scores into the six categories that the game expects.
|
||
total_scores = sorted(
|
||
[
|
||
sum([score.points for score in scores])
|
||
for userid, scores in scores_by_user.items()
|
||
],
|
||
reverse=True,
|
||
)
|
||
basic_scores = sorted(
|
||
[
|
||
sum([score.points for score in scores if score.chart == self.CHART_TYPE_BASIC])
|
||
for userid, scores in scores_by_user.items()
|
||
],
|
||
reverse=True,
|
||
)
|
||
medium_scores = sorted(
|
||
[
|
||
sum([score.points for score in scores if score.chart == self.CHART_TYPE_MEDIUM])
|
||
for userid, scores in scores_by_user.items()
|
||
],
|
||
reverse=True,
|
||
)
|
||
hard_scores = sorted(
|
||
[
|
||
sum([score.points for score in scores if score.chart == self.CHART_TYPE_HARD])
|
||
for userid, scores in scores_by_user.items()
|
||
],
|
||
reverse=True,
|
||
)
|
||
special_scores = sorted(
|
||
[
|
||
sum([score.points for score in scores if score.chart == self.CHART_TYPE_SPECIAL])
|
||
for userid, scores in scores_by_user.items()
|
||
],
|
||
reverse=True,
|
||
)
|
||
new_scores = sorted(
|
||
[
|
||
sum([score.points for score in scores if score.id in new_songs])
|
||
for userid, scores in scores_by_user.items()
|
||
],
|
||
reverse=True,
|
||
)
|
||
|
||
# Guarantee that a zero score is at the end of every list, so that it makes
|
||
# the algorithm for figuring out place have no edge case.
|
||
total_scores.append(0)
|
||
basic_scores.append(0)
|
||
medium_scores.append(0)
|
||
hard_scores.append(0)
|
||
special_scores.append(0)
|
||
new_scores.append(0)
|
||
|
||
# Now, figure out where we fit based on the scores sent from the game.
|
||
user_place = [1, 1, 1, 1, 1, 1]
|
||
which_score = [
|
||
total_scores,
|
||
basic_scores,
|
||
medium_scores,
|
||
hard_scores,
|
||
special_scores,
|
||
new_scores,
|
||
]
|
||
for i in range(len(user_place)):
|
||
current_score = current_scores[i]
|
||
scores = which_score[i]
|
||
for score in scores:
|
||
if current_score >= score:
|
||
break
|
||
user_place[i] = user_place[i] + 1
|
||
|
||
root = Node.void('player')
|
||
scorenode = Node.void('score')
|
||
root.add_child(scorenode)
|
||
scorenode.add_child(Node.s32_array('rank', user_place))
|
||
scorenode.add_child(Node.s32_array('score', [0] * 6))
|
||
scorenode.add_child(Node.s32_array('allrank', [len(total_scores)] * 6))
|
||
return root
|
||
|
||
def handle_player_rb4delete_request(self, request: Node) -> Node:
|
||
return Node.void('player')
|
||
|
||
def handle_player_rb4read_request(self, request: Node) -> Node:
|
||
refid = request.child_value('rid')
|
||
profile = self.get_profile_by_refid(refid)
|
||
if profile:
|
||
return profile
|
||
return Node.void('player')
|
||
|
||
def handle_player_rb4succeed_request(self, request: Node) -> Node:
|
||
refid = request.child_value('rid')
|
||
userid = self.data.remote.user.from_refid(self.game, self.version, refid)
|
||
if userid is not None:
|
||
previous_version = self.previous_version()
|
||
profile = previous_version.get_profile(userid)
|
||
achievements = self.data.local.user.get_achievements(previous_version.game, previous_version.version, userid)
|
||
scores = self.data.remote.music.get_scores(previous_version.game, previous_version.version, userid)
|
||
else:
|
||
profile = None
|
||
|
||
root = Node.void('player')
|
||
|
||
if profile is None:
|
||
# Return empty succeed to say this is new
|
||
root.add_child(Node.string('name', ''))
|
||
root.add_child(Node.s16('lv', -1))
|
||
root.add_child(Node.s32('exp', -1))
|
||
root.add_child(Node.s32('grd', -1))
|
||
root.add_child(Node.s32('ap', -1))
|
||
root.add_child(Node.s32('money', -1))
|
||
root.add_child(Node.void('released'))
|
||
root.add_child(Node.void('mrecord'))
|
||
else:
|
||
# Return previous profile formatted to say this is data succession
|
||
root.add_child(Node.string('name', profile.get_str('name')))
|
||
root.add_child(Node.s16('lv', profile.get_int('lvl')))
|
||
root.add_child(Node.s32('exp', profile.get_int('exp')))
|
||
root.add_child(Node.s32('grd', profile.get_int('mg'))) # This is a guess
|
||
root.add_child(Node.s32('ap', profile.get_int('ap')))
|
||
root.add_child(Node.s32('money', 0))
|
||
|
||
released = Node.void('released')
|
||
root.add_child(released)
|
||
for item in achievements:
|
||
if item.type != 'item_0':
|
||
continue
|
||
|
||
released.add_child(Node.s16('i', item.id))
|
||
|
||
mrecord = Node.void('mrecord')
|
||
root.add_child(mrecord)
|
||
for score in scores:
|
||
mrec = Node.void('mrec')
|
||
mrecord.add_child(mrec)
|
||
mrec.add_child(Node.s16('mid', score.id))
|
||
mrec.add_child(Node.s8('ntgrd', score.chart))
|
||
mrec.add_child(Node.s32('pc', score.plays))
|
||
mrec.add_child(Node.s8('ct', self.__db_to_game_clear_type(score.data.get_int('clear_type'))))
|
||
mrec.add_child(Node.s16('ar', score.data.get_int('achievement_rate')))
|
||
mrec.add_child(Node.s16('scr', score.points))
|
||
mrec.add_child(Node.s16('ms', score.data.get_int('miss_count')))
|
||
mrec.add_child(Node.u16('ver', 0))
|
||
mrec.add_child(Node.s32('bst', score.timestamp))
|
||
mrec.add_child(Node.s32('bat', score.data.get_int('best_achievement_rate_time')))
|
||
mrec.add_child(Node.s32('bct', score.data.get_int('best_clear_type_time')))
|
||
mrec.add_child(Node.s32('bmt', score.data.get_int('best_miss_count_time')))
|
||
|
||
return root
|
||
|
||
def handle_player_rb4write_request(self, request: Node) -> Node:
|
||
refid = request.child_value('pdata/account/rid')
|
||
profile = self.put_profile_by_refid(refid, request)
|
||
root = Node.void('player')
|
||
|
||
if profile is None:
|
||
root.add_child(Node.s32('uid', 0))
|
||
else:
|
||
root.add_child(Node.s32('uid', profile.extid))
|
||
return root
|
||
|
||
def format_profile(self, userid: UserID, profile: Profile) -> Node:
|
||
statistics = self.get_play_statistics(userid)
|
||
game_config = self.get_game_config()
|
||
achievements = self.data.local.user.get_achievements(self.game, self.version, userid)
|
||
links = self.data.local.user.get_links(self.game, self.version, userid)
|
||
root = Node.void('player')
|
||
pdata = Node.void('pdata')
|
||
root.add_child(pdata)
|
||
|
||
# Account info
|
||
account = Node.void('account')
|
||
pdata.add_child(account)
|
||
account.add_child(Node.s32('usrid', profile.extid))
|
||
account.add_child(Node.s32('tpc', statistics.total_plays))
|
||
account.add_child(Node.s32('dpc', statistics.today_plays))
|
||
account.add_child(Node.s32('crd', 1))
|
||
account.add_child(Node.s32('brd', 1))
|
||
account.add_child(Node.s32('tdc', statistics.total_days))
|
||
account.add_child(Node.s32('intrvld', 0))
|
||
account.add_child(Node.s16('ver', 1))
|
||
account.add_child(Node.u64('pst', 0))
|
||
account.add_child(Node.u64('st', Time.now() * 1000))
|
||
account.add_child(Node.u8('debutVer', 2))
|
||
|
||
# Base profile info
|
||
base = Node.void('base')
|
||
pdata.add_child(base)
|
||
base.add_child(Node.string('name', profile.get_str('name')))
|
||
base.add_child(Node.s32('exp', profile.get_int('exp')))
|
||
base.add_child(Node.s32('lv', profile.get_int('lvl')))
|
||
base.add_child(Node.s32('mg', profile.get_int('mg')))
|
||
base.add_child(Node.s32('ap', profile.get_int('ap')))
|
||
base.add_child(Node.string('cmnt', ''))
|
||
base.add_child(Node.s32('uattr', profile.get_int('uattr')))
|
||
base.add_child(Node.s32('money', profile.get_int('money')))
|
||
base.add_child(Node.s32('tbs', -1))
|
||
base.add_child(Node.s32('tbs_r', -1))
|
||
base.add_child(Node.s32('tbgs', -1))
|
||
base.add_child(Node.s32('tbgs_r', -1))
|
||
base.add_child(Node.s32('tbms', -1))
|
||
base.add_child(Node.s32('tbms_r', -1))
|
||
base.add_child(Node.s32('qe_win', -1))
|
||
base.add_child(Node.s32('qe_legend', -1))
|
||
base.add_child(Node.s32('qe2_win', -1))
|
||
base.add_child(Node.s32('qe2_legend', -1))
|
||
base.add_child(Node.s32('qe3_win', -1))
|
||
base.add_child(Node.s32('qe3_legend', -1))
|
||
base.add_child(Node.s16_array('mlog', [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1]))
|
||
base.add_child(Node.s32('class', profile.get_int('class')))
|
||
base.add_child(Node.s32('class_ar', profile.get_int('class_ar')))
|
||
base.add_child(Node.s32('getrfl', -1))
|
||
base.add_child(Node.s32('upper_pt', profile.get_int('upper_pt')))
|
||
|
||
# Rivals
|
||
rival = Node.void('rival')
|
||
pdata.add_child(rival)
|
||
slotid = 0
|
||
for link in links:
|
||
if link.type != 'rival':
|
||
continue
|
||
|
||
rprofile = self.get_profile(link.other_userid)
|
||
if rprofile is None:
|
||
continue
|
||
lobbyinfo = self.data.local.lobby.get_play_session_info(self.game, self.version, link.other_userid)
|
||
if lobbyinfo is None:
|
||
lobbyinfo = ValidatedDict()
|
||
|
||
r = Node.void('r')
|
||
rival.add_child(r)
|
||
r.add_child(Node.s32('slot_id', slotid))
|
||
r.add_child(Node.s32('id', rprofile.extid))
|
||
r.add_child(Node.string('name', rprofile.get_str('name')))
|
||
r.add_child(Node.s32('icon', profile.get_dict('config').get_int('icon_id')))
|
||
r.add_child(Node.s32('m_level', profile.get_int('mg')))
|
||
r.add_child(Node.s32('class', profile.get_int('class')))
|
||
r.add_child(Node.s32('class_ar', profile.get_int('class_ar')))
|
||
r.add_child(Node.bool('friend', True))
|
||
r.add_child(Node.bool('target', False))
|
||
r.add_child(Node.u32('time', lobbyinfo.get_int('time')))
|
||
r.add_child(Node.u8_array('ga', lobbyinfo.get_int_array('ga', 4)))
|
||
r.add_child(Node.u16('gp', lobbyinfo.get_int('gp')))
|
||
r.add_child(Node.u8_array('ipn', lobbyinfo.get_int_array('la', 4)))
|
||
r.add_child(Node.u8_array('pnid', lobbyinfo.get_int_array('pnid', 16)))
|
||
slotid = slotid + 1
|
||
|
||
# Stamps
|
||
stamp = Node.void('stamp')
|
||
stampdict = profile.get_dict('stamp')
|
||
pdata.add_child(stamp)
|
||
stamp.add_child(Node.s32_array('stmpcnt', stampdict.get_int_array('stmpcnt', 10)))
|
||
stamp.add_child(Node.s64('area', stampdict.get_int('area')))
|
||
stamp.add_child(Node.s64('prfvst', stampdict.get_int('prfvst')))
|
||
|
||
# Configuration
|
||
configdict = profile.get_dict('config')
|
||
config = Node.void('config')
|
||
pdata.add_child(config)
|
||
config.add_child(Node.u8('msel_bgm', configdict.get_int('msel_bgm')))
|
||
config.add_child(Node.u8('narrowdown_type', configdict.get_int('narrowdown_type')))
|
||
config.add_child(Node.s16('icon_id', configdict.get_int('icon_id')))
|
||
config.add_child(Node.s16('byword_0', configdict.get_int('byword_0')))
|
||
config.add_child(Node.s16('byword_1', configdict.get_int('byword_1')))
|
||
config.add_child(Node.bool('is_auto_byword_0', configdict.get_bool('is_auto_byword_0')))
|
||
config.add_child(Node.bool('is_auto_byword_1', configdict.get_bool('is_auto_byword_1')))
|
||
config.add_child(Node.u8('mrec_type', configdict.get_int('mrec_type')))
|
||
config.add_child(Node.u8('tab_sel', configdict.get_int('tab_sel')))
|
||
config.add_child(Node.u8('card_disp', configdict.get_int('card_disp')))
|
||
config.add_child(Node.u8('score_tab_disp', configdict.get_int('score_tab_disp')))
|
||
config.add_child(Node.s16('last_music_id', configdict.get_int('last_music_id', -1)))
|
||
config.add_child(Node.u8('last_note_grade', configdict.get_int('last_note_grade')))
|
||
config.add_child(Node.u8('sort_type', configdict.get_int('sort_type')))
|
||
config.add_child(Node.u8('rival_panel_type', configdict.get_int('rival_panel_type')))
|
||
config.add_child(Node.u64('random_entry_work', configdict.get_int('random_entry_work')))
|
||
config.add_child(Node.u64('custom_folder_work', configdict.get_int('custom_folder_work')))
|
||
config.add_child(Node.u8('folder_type', configdict.get_int('folder_type')))
|
||
config.add_child(Node.u8('folder_lamp_type', configdict.get_int('folder_lamp_type')))
|
||
config.add_child(Node.bool('is_tweet', configdict.get_bool('is_tweet')))
|
||
config.add_child(Node.bool('is_link_twitter', configdict.get_bool('is_link_twitter')))
|
||
|
||
# Customizations
|
||
customdict = profile.get_dict('custom')
|
||
custom = Node.void('custom')
|
||
pdata.add_child(custom)
|
||
custom.add_child(Node.u8('st_shot', customdict.get_int('st_shot')))
|
||
custom.add_child(Node.u8('st_frame', customdict.get_int('st_frame')))
|
||
custom.add_child(Node.u8('st_expl', customdict.get_int('st_expl')))
|
||
custom.add_child(Node.u8('st_bg', customdict.get_int('st_bg')))
|
||
custom.add_child(Node.u8('st_shot_vol', customdict.get_int('st_shot_vol')))
|
||
custom.add_child(Node.u8('st_bg_bri', customdict.get_int('st_bg_bri')))
|
||
custom.add_child(Node.u8('st_obj_size', customdict.get_int('st_obj_size')))
|
||
custom.add_child(Node.u8('st_jr_gauge', customdict.get_int('st_jr_gauge')))
|
||
custom.add_child(Node.u8('st_clr_gauge', customdict.get_int('st_clr_gauge')))
|
||
custom.add_child(Node.u8('st_jdg_disp', customdict.get_int('st_jdg_disp')))
|
||
custom.add_child(Node.u8('st_tm_disp', customdict.get_int('st_tm_disp')))
|
||
custom.add_child(Node.u8('st_rnd', customdict.get_int('st_rnd')))
|
||
custom.add_child(Node.u8('st_hazard', customdict.get_int('st_hazard')))
|
||
custom.add_child(Node.u8('st_clr_cond', customdict.get_int('st_clr_cond')))
|
||
custom.add_child(Node.s16_array('schat_0', customdict.get_int_array('schat_0', 10)))
|
||
custom.add_child(Node.s16_array('schat_1', customdict.get_int_array('schat_1', 10)))
|
||
custom.add_child(Node.u8('cheer_voice', customdict.get_int('cheer_voice')))
|
||
custom.add_child(Node.u8('same_time_note_disp', customdict.get_int('same_time_note_disp')))
|
||
|
||
# Unlocks
|
||
released = Node.void('released')
|
||
pdata.add_child(released)
|
||
|
||
for item in achievements:
|
||
if item.type[:5] != 'item_':
|
||
continue
|
||
itemtype = int(item.type[5:])
|
||
if game_config.get_bool('force_unlock_songs') and itemtype == 0:
|
||
# Don't echo unlocks when we're force unlocking, we'll do it later
|
||
continue
|
||
|
||
info = Node.void('info')
|
||
released.add_child(info)
|
||
info.add_child(Node.u8('type', itemtype))
|
||
info.add_child(Node.u16('id', item.id))
|
||
info.add_child(Node.u16('param', item.data.get_int('param')))
|
||
|
||
if game_config.get_bool('force_unlock_songs'):
|
||
ids: Dict[int, int] = {}
|
||
songs = self.data.local.music.get_all_songs(self.game, self.version)
|
||
for song in songs:
|
||
if song.id not in ids:
|
||
ids[song.id] = 0
|
||
|
||
if song.data.get_int('difficulty') > 0:
|
||
ids[song.id] = ids[song.id] | (1 << song.chart)
|
||
|
||
for songid in ids:
|
||
if ids[songid] == 0:
|
||
continue
|
||
|
||
info = Node.void('info')
|
||
released.add_child(info)
|
||
info.add_child(Node.u8('type', 0))
|
||
info.add_child(Node.u16('id', songid))
|
||
info.add_child(Node.u16('param', ids[songid]))
|
||
|
||
# Announcements
|
||
announce = Node.void('announce')
|
||
pdata.add_child(announce)
|
||
|
||
for announcement in achievements:
|
||
if announcement.type[:13] != 'announcement_':
|
||
continue
|
||
announcementtype = int(announcement.type[13:])
|
||
|
||
info = Node.void('info')
|
||
announce.add_child(info)
|
||
info.add_child(Node.u8('type', announcementtype))
|
||
info.add_child(Node.u16('id', announcement.id))
|
||
info.add_child(Node.u16('param', announcement.data.get_int('param')))
|
||
info.add_child(Node.bool('bneedannounce', announcement.data.get_bool('need')))
|
||
|
||
# Dojo ranking return
|
||
dojo = Node.void('dojo')
|
||
pdata.add_child(dojo)
|
||
|
||
for entry in achievements:
|
||
if entry.type != 'dojo':
|
||
continue
|
||
|
||
rec = Node.void('rec')
|
||
dojo.add_child(rec)
|
||
rec.add_child(Node.s32('class', entry.id))
|
||
rec.add_child(Node.s32('clear_type', entry.data.get_int('clear_type')))
|
||
rec.add_child(Node.s32('total_ar', entry.data.get_int('ar')))
|
||
rec.add_child(Node.s32('total_score', entry.data.get_int('score')))
|
||
rec.add_child(Node.s32('play_count', entry.data.get_int('plays')))
|
||
rec.add_child(Node.s32('last_play_time', entry.data.get_int('play_timestamp')))
|
||
rec.add_child(Node.s32('record_update_time', entry.data.get_int('record_timestamp')))
|
||
rec.add_child(Node.s32('rank', 0))
|
||
|
||
# Player Parameters
|
||
player_param = Node.void('player_param')
|
||
pdata.add_child(player_param)
|
||
|
||
for param in achievements:
|
||
if param.type[:13] != 'player_param_':
|
||
continue
|
||
itemtype = int(param.type[13:])
|
||
|
||
itemnode = Node.void('item')
|
||
player_param.add_child(itemnode)
|
||
itemnode.add_child(Node.s32('type', itemtype))
|
||
itemnode.add_child(Node.s32('bank', param.id))
|
||
itemnode.add_child(Node.s32_array('data', param.data.get_int_array('data', 256)))
|
||
|
||
# Shop score for players
|
||
self.__add_shop_score(pdata)
|
||
|
||
# Quest data
|
||
questdict = profile.get_dict('quest')
|
||
quest = Node.void('quest')
|
||
pdata.add_child(quest)
|
||
quest.add_child(Node.s16('eye_color', questdict.get_int('eye_color')))
|
||
quest.add_child(Node.s16('body_color', questdict.get_int('body_color')))
|
||
quest.add_child(Node.s16('item', questdict.get_int('item')))
|
||
quest.add_child(Node.string('comment', ''))
|
||
|
||
# Derby settings
|
||
derby = Node.void('derby')
|
||
pdata.add_child(derby)
|
||
derby.add_child(Node.bool('is_open', False))
|
||
|
||
# Codebreaking stuff
|
||
codebreaking = Node.void('codebreaking')
|
||
pdata.add_child(codebreaking)
|
||
codebreaking.add_child(Node.s32('cb_id', -1))
|
||
codebreaking.add_child(Node.s32('cb_sub_id', -1))
|
||
codebreaking.add_child(Node.s32('music_id', -1))
|
||
codebreaking.add_child(Node.string('question', ''))
|
||
|
||
# Unknown IIDX link crap
|
||
iidx_linkage = Node.void('iidx_linkage')
|
||
pdata.add_child(iidx_linkage)
|
||
iidx_linkage.add_child(Node.s32('linkage_id', -1))
|
||
iidx_linkage.add_child(Node.s32('phase', -1))
|
||
iidx_linkage.add_child(Node.s64('long_bit_0', -1))
|
||
iidx_linkage.add_child(Node.s64('long_bit_1', -1))
|
||
iidx_linkage.add_child(Node.s64('long_bit_2', -1))
|
||
iidx_linkage.add_child(Node.s64('long_bit_3', -1))
|
||
iidx_linkage.add_child(Node.s64('long_bit_4', -1))
|
||
iidx_linkage.add_child(Node.s64('long_bit_5', -1))
|
||
iidx_linkage.add_child(Node.s32('add_0', -1))
|
||
iidx_linkage.add_child(Node.s32('add_1', -1))
|
||
iidx_linkage.add_child(Node.s32('add_2', -1))
|
||
iidx_linkage.add_child(Node.s32('add_3', -1))
|
||
|
||
# Unknown event crap
|
||
pue = Node.void('pue')
|
||
pdata.add_child(pue)
|
||
pue.add_child(Node.s32('event_id', -1))
|
||
pue.add_child(Node.s32('point', -1))
|
||
pue.add_child(Node.s32('value0', -1))
|
||
pue.add_child(Node.s32('value1', -1))
|
||
pue.add_child(Node.s32('value2', -1))
|
||
pue.add_child(Node.s32('value3', -1))
|
||
pue.add_child(Node.s32('value4', -1))
|
||
pue.add_child(Node.s32('start_time', -1))
|
||
pue.add_child(Node.s32('end_time', -1))
|
||
|
||
return root
|
||
|
||
def unformat_profile(self, userid: UserID, request: Node, oldprofile: Profile) -> Profile:
|
||
game_config = self.get_game_config()
|
||
newprofile = oldprofile.clone()
|
||
|
||
# Save base player profile info
|
||
newprofile.replace_int('lid', ID.parse_machine_id(request.child_value('pdata/account/lid')))
|
||
newprofile.replace_str('name', request.child_value('pdata/base/name'))
|
||
newprofile.replace_int('exp', request.child_value('pdata/base/exp'))
|
||
newprofile.replace_int('lvl', request.child_value('pdata/base/lvl'))
|
||
newprofile.replace_int('mg', request.child_value('pdata/base/mg'))
|
||
newprofile.replace_int('ap', request.child_value('pdata/base/ap'))
|
||
newprofile.replace_int('money', request.child_value('pdata/base/money'))
|
||
newprofile.replace_int('class', request.child_value('pdata/base/class'))
|
||
newprofile.replace_int('class_ar', request.child_value('pdata/base/class_ar'))
|
||
newprofile.replace_int('upper_pt', request.child_value('pdata/base/upper_pt'))
|
||
|
||
# Save stamps
|
||
stampdict = newprofile.get_dict('stamp')
|
||
stamp = request.child('pdata/stamp')
|
||
if stamp:
|
||
stampdict.replace_int_array('stmpcnt', 10, stamp.child_value('stmpcnt'))
|
||
stampdict.replace_int('area', stamp.child_value('area'))
|
||
stampdict.replace_int('prfvst', stamp.child_value('prfvst'))
|
||
newprofile.replace_dict('stamp', stampdict)
|
||
|
||
# Save quest stuff
|
||
questdict = newprofile.get_dict('quest')
|
||
quest = request.child('pdata/quest')
|
||
if quest:
|
||
questdict.replace_int('eye_color', quest.child_value('eye_color'))
|
||
questdict.replace_int('body_color', quest.child_value('body_color'))
|
||
questdict.replace_int('item', quest.child_value('item'))
|
||
newprofile.replace_dict('quest', questdict)
|
||
|
||
# Save player dojo
|
||
dojo = request.child('pdata/dojo')
|
||
if dojo:
|
||
dojoid = dojo.child_value('class')
|
||
clear_type = dojo.child_value('clear_type')
|
||
ar = dojo.child_value('t_ar')
|
||
score = dojo.child_value('t_score')
|
||
|
||
# Figure out timestamp stuff
|
||
data = self.data.local.user.get_achievement(
|
||
self.game,
|
||
self.version,
|
||
userid,
|
||
dojoid,
|
||
'dojo',
|
||
) or ValidatedDict()
|
||
|
||
if ar >= data.get_int('ar'):
|
||
# We set a new achievement rate, keep the new values
|
||
record_time = Time.now()
|
||
else:
|
||
# We didn't, keep the old values for achievement rate, but
|
||
# override score and clear_type only if they were better.
|
||
record_time = data.get_int('record_timestamp')
|
||
ar = data.get_int('ar')
|
||
score = max(score, data.get_int('score'))
|
||
clear_type = max(clear_type, data.get_int('clear_type'))
|
||
|
||
play_time = Time.now()
|
||
plays = data.get_int('plays') + 1
|
||
|
||
self.data.local.user.put_achievement(
|
||
self.game,
|
||
self.version,
|
||
userid,
|
||
dojoid,
|
||
'dojo',
|
||
{
|
||
'clear_type': clear_type,
|
||
'ar': ar,
|
||
'score': score,
|
||
'plays': plays,
|
||
'play_timestamp': play_time,
|
||
'record_timestamp': record_time,
|
||
},
|
||
)
|
||
|
||
# Save player config
|
||
configdict = newprofile.get_dict('config')
|
||
config = request.child('pdata/config')
|
||
if config:
|
||
configdict.replace_int('msel_bgm', config.child_value('msel_bgm'))
|
||
configdict.replace_int('narrowdown_type', config.child_value('narrowdown_type'))
|
||
configdict.replace_int('icon_id', config.child_value('icon_id'))
|
||
configdict.replace_int('byword_0', config.child_value('byword_0'))
|
||
configdict.replace_int('byword_1', config.child_value('byword_1'))
|
||
configdict.replace_bool('is_auto_byword_0', config.child_value('is_auto_byword_0'))
|
||
configdict.replace_bool('is_auto_byword_1', config.child_value('is_auto_byword_1'))
|
||
configdict.replace_int('mrec_type', config.child_value('mrec_type'))
|
||
configdict.replace_int('tab_sel', config.child_value('tab_sel'))
|
||
configdict.replace_int('card_disp', config.child_value('card_disp'))
|
||
configdict.replace_int('score_tab_disp', config.child_value('score_tab_disp'))
|
||
configdict.replace_int('last_music_id', config.child_value('last_music_id'))
|
||
configdict.replace_int('last_note_grade', config.child_value('last_note_grade'))
|
||
configdict.replace_int('sort_type', config.child_value('sort_type'))
|
||
configdict.replace_int('rival_panel_type', config.child_value('rival_panel_type'))
|
||
configdict.replace_int('random_entry_work', config.child_value('random_entry_work'))
|
||
configdict.replace_int('custom_folder_work', config.child_value('custom_folder_work'))
|
||
configdict.replace_int('folder_type', config.child_value('folder_type'))
|
||
configdict.replace_int('folder_lamp_type', config.child_value('folder_lamp_type'))
|
||
configdict.replace_bool('is_tweet', config.child_value('is_tweet'))
|
||
configdict.replace_bool('is_link_twitter', config.child_value('is_link_twitter'))
|
||
newprofile.replace_dict('config', configdict)
|
||
|
||
# Save player custom settings
|
||
customdict = newprofile.get_dict('custom')
|
||
custom = request.child('pdata/custom')
|
||
if custom:
|
||
customdict.replace_int('st_shot', custom.child_value('st_shot'))
|
||
customdict.replace_int('st_frame', custom.child_value('st_frame'))
|
||
customdict.replace_int('st_expl', custom.child_value('st_expl'))
|
||
customdict.replace_int('st_bg', custom.child_value('st_bg'))
|
||
customdict.replace_int('st_shot_vol', custom.child_value('st_shot_vol'))
|
||
customdict.replace_int('st_bg_bri', custom.child_value('st_bg_bri'))
|
||
customdict.replace_int('st_obj_size', custom.child_value('st_obj_size'))
|
||
customdict.replace_int('st_jr_gauge', custom.child_value('st_jr_gauge'))
|
||
customdict.replace_int('st_clr_gauge', custom.child_value('st_clr_gauge'))
|
||
customdict.replace_int('st_jdg_disp', custom.child_value('st_jdg_disp'))
|
||
customdict.replace_int('st_tm_disp', custom.child_value('st_tm_disp'))
|
||
customdict.replace_int('st_rnd', custom.child_value('st_rnd'))
|
||
customdict.replace_int('st_hazard', custom.child_value('st_hazard'))
|
||
customdict.replace_int('st_clr_cond', custom.child_value('st_clr_cond'))
|
||
customdict.replace_int_array('schat_0', 10, custom.child_value('schat_0'))
|
||
customdict.replace_int_array('schat_1', 10, custom.child_value('schat_1'))
|
||
customdict.replace_int('cheer_voice', custom.child_value('cheer_voice'))
|
||
customdict.replace_int('same_time_note_disp', custom.child_value('same_time_note_disp'))
|
||
newprofile.replace_dict('custom', customdict)
|
||
|
||
# Save player parameter info
|
||
params = request.child('pdata/player_param')
|
||
if params:
|
||
for child in params.children:
|
||
if child.name != 'item':
|
||
continue
|
||
|
||
item_type = child.child_value('type')
|
||
bank = child.child_value('bank')
|
||
paramdata = child.child_value('data') or []
|
||
while len(paramdata) < 256:
|
||
paramdata.append(0)
|
||
self.data.local.user.put_achievement(
|
||
self.game,
|
||
self.version,
|
||
userid,
|
||
bank,
|
||
f'player_param_{item_type}',
|
||
{
|
||
'data': paramdata,
|
||
},
|
||
)
|
||
|
||
# Save player episode info
|
||
episode = request.child('pdata/episode')
|
||
if episode:
|
||
for child in episode.children:
|
||
if child.name != 'info':
|
||
continue
|
||
|
||
# I assume this is copypasta, but I want to be sure
|
||
extid = child.child_value('user_id')
|
||
if extid != newprofile.extid:
|
||
raise Exception(f'Unexpected user ID, got {extid} expecting {newprofile.extid}')
|
||
|
||
episode_type = child.child_value('type')
|
||
episode_value0 = child.child_value('value0')
|
||
episode_value1 = child.child_value('value1')
|
||
episode_text = child.child_value('text')
|
||
episode_time = child.child_value('time')
|
||
self.data.local.user.put_achievement(
|
||
self.game,
|
||
self.version,
|
||
userid,
|
||
episode_type,
|
||
'episode',
|
||
{
|
||
'value0': episode_value0,
|
||
'value1': episode_value1,
|
||
'text': episode_text,
|
||
'time': episode_time,
|
||
},
|
||
)
|
||
|
||
# Save released info
|
||
released = request.child('pdata/released')
|
||
if released:
|
||
for child in released.children:
|
||
if child.name != 'info':
|
||
continue
|
||
|
||
item_id = child.child_value('id')
|
||
item_type = child.child_value('type')
|
||
param = child.child_value('param')
|
||
if game_config.get_bool('force_unlock_songs') and item_type == 0:
|
||
# Don't save unlocks when we're force unlocking
|
||
continue
|
||
|
||
self.data.local.user.put_achievement(
|
||
self.game,
|
||
self.version,
|
||
userid,
|
||
item_id,
|
||
f'item_{item_type}',
|
||
{
|
||
'param': param,
|
||
},
|
||
)
|
||
|
||
# Save announce info
|
||
announce = request.child('pdata/announce')
|
||
if announce:
|
||
for child in announce.children:
|
||
if child.name != 'info':
|
||
continue
|
||
|
||
announce_id = child.child_value('id')
|
||
announce_type = child.child_value('type')
|
||
param = child.child_value('param')
|
||
need = child.child_value('bneedannounce')
|
||
self.data.local.user.put_achievement(
|
||
self.game,
|
||
self.version,
|
||
userid,
|
||
announce_id,
|
||
f'announcement_{announce_type}',
|
||
{
|
||
'param': param,
|
||
'need': need,
|
||
},
|
||
)
|
||
|
||
# Grab any new rivals added during this play session
|
||
rivalnode = request.child('pdata/rival')
|
||
if rivalnode:
|
||
for child in rivalnode.children:
|
||
if child.name != 'r':
|
||
continue
|
||
|
||
extid = child.child_value('id')
|
||
other_userid = self.data.remote.user.from_extid(self.game, self.version, extid)
|
||
if other_userid is None:
|
||
continue
|
||
|
||
self.data.local.user.put_link(
|
||
self.game,
|
||
self.version,
|
||
userid,
|
||
'rival',
|
||
other_userid,
|
||
{},
|
||
)
|
||
|
||
# Grab any new records set during this play session
|
||
songplays = request.child('pdata/stglog')
|
||
if songplays:
|
||
for child in songplays.children:
|
||
if child.name != 'log':
|
||
continue
|
||
|
||
songid = child.child_value('mid')
|
||
chart = child.child_value('ng')
|
||
clear_type = child.child_value('ct')
|
||
if songid == 0 and chart == 0 and clear_type == -1:
|
||
# Dummy song save during profile create
|
||
continue
|
||
|
||
points = child.child_value('sc')
|
||
achievement_rate = child.child_value('ar')
|
||
param = child.child_value('param')
|
||
miss_count = child.child_value('jt_ms')
|
||
|
||
# Param is some random bits along with the combo type
|
||
combo_type = param & 0x3
|
||
param = param ^ combo_type
|
||
|
||
clear_type = self.__game_to_db_clear_type(clear_type)
|
||
combo_type = self.__game_to_db_combo_type(combo_type, miss_count)
|
||
self.update_score(
|
||
userid,
|
||
songid,
|
||
chart,
|
||
points,
|
||
achievement_rate,
|
||
clear_type,
|
||
combo_type,
|
||
miss_count,
|
||
param=param,
|
||
)
|
||
|
||
# Keep track of play statistics
|
||
self.update_play_statistics(userid)
|
||
|
||
return newprofile
|