1
0
mirror of synced 2024-12-16 00:01:15 +01:00
bemaniutils/bemani/backend/jubeat/base.py

371 lines
13 KiB
Python

# vim: set fileencoding=utf-8
import random
import struct
from typing import Dict, Iterable, List, Optional, Set, Tuple
from typing_extensions import Final
from bemani.backend.base import Base
from bemani.backend.core import CoreHandler, CardManagerHandler, PASELIHandler
from bemani.common import DBConstants, GameConstants, ValidatedDict, Model, Profile
from bemani.data import Data, Score, UserID, Config
from bemani.protocol import Node
class JubeatBase(CoreHandler, CardManagerHandler, PASELIHandler, Base):
"""
Base game class for all Jubeat versions. Handles common functionality for getting
profiles based on refid, creating new profiles, looking up and saving scores.
"""
game: GameConstants = GameConstants.JUBEAT
GAME_FLAG_BIT_PLAYED: Final[int] = 0x1
GAME_FLAG_BIT_CLEARED: Final[int] = 0x2
GAME_FLAG_BIT_FULL_COMBO: Final[int] = 0x4
GAME_FLAG_BIT_EXCELLENT: Final[int] = 0x8
GAME_FLAG_BIT_NEARLY_FULL_COMBO: Final[int] = 0x10
GAME_FLAG_BIT_NEARLY_EXCELLENT: Final[int] = 0x20
GAME_FLAG_BIT_NO_GRAY: Final[int] = 0x40
GAME_FLAG_BIT_NO_YELLOW: Final[int] = 0x80
PLAY_MEDAL_FAILED: Final[int] = DBConstants.JUBEAT_PLAY_MEDAL_FAILED
PLAY_MEDAL_CLEARED: Final[int] = DBConstants.JUBEAT_PLAY_MEDAL_CLEARED
PLAY_MEDAL_NEARLY_FULL_COMBO: Final[
int
] = DBConstants.JUBEAT_PLAY_MEDAL_NEARLY_FULL_COMBO
PLAY_MEDAL_FULL_COMBO: Final[int] = DBConstants.JUBEAT_PLAY_MEDAL_FULL_COMBO
PLAY_MEDAL_NEARLY_EXCELLENT: Final[
int
] = DBConstants.JUBEAT_PLAY_MEDAL_NEARLY_EXCELLENT
PLAY_MEDAL_EXCELLENT: Final[int] = DBConstants.JUBEAT_PLAY_MEDAL_EXCELLENT
CHART_TYPE_BASIC: Final[int] = 0
CHART_TYPE_ADVANCED: Final[int] = 1
CHART_TYPE_EXTREME: Final[int] = 2
CHART_TYPE_HARD_BASIC: Final[int] = 3
CHART_TYPE_HARD_ADVANCED: Final[int] = 4
CHART_TYPE_HARD_EXTREME: Final[int] = 5
def __init__(self, data: Data, config: Config, model: Model) -> None:
super().__init__(data, config, model)
if model.rev == "X" or model.rev == "Y":
self.omnimix = True
else:
self.omnimix = False
@property
def music_version(self) -> int:
if self.omnimix:
return DBConstants.OMNIMIX_VERSION_BUMP + self.version
return self.version
def previous_version(self) -> Optional["JubeatBase"]:
"""
Returns the previous version of the game, based on this game. Should
be overridden.
"""
return None
def put_profile(self, userid: UserID, profile: Profile) -> None:
"""
Save a new profile for this user given a game/version. Overrides but calls
the same functionality in Base, to ensure we don't save calculated values.
Parameters:
userid - The user ID we are saving the profile for.
profile - A dictionary that should be looked up later using get_profile.
"""
if "has_old_version" in profile:
del profile["has_old_version"]
super().put_profile(userid, profile)
def format_profile(self, userid: UserID, profile: Profile) -> Node:
"""
Base handler for a profile. Given a userid and a profile dictionary,
return a Node representing a profile. Should be overridden.
"""
return Node.void("gametop")
def format_scores(
self, userid: UserID, profile: Profile, scores: List[Score]
) -> Node:
"""
Base handler for a score list. Given a userid, profile and a score list,
return a Node representing a score list. Should be overridden.
"""
return Node.void("gametop")
def unformat_profile(
self, userid: UserID, request: Node, oldprofile: Profile
) -> Profile:
"""
Base handler for profile parsing. Given a request and an old profile,
return a new profile that's been updated with the contents of the request.
Should be overridden.
"""
return oldprofile
def get_profile_by_refid(self, refid: Optional[str]) -> Optional[Node]:
"""
Given a RefID, return a formatted profile node. Basically every game
needs a profile lookup, even if it handles where that happens in
a different request. This is provided for code deduplication.
"""
if refid is None:
return None
# First try to load the actual profile
userid = self.data.remote.user.from_refid(self.game, self.version, refid)
profile = self.get_profile(userid)
if profile is None:
return None
# Now try to find out if the profile is new or old
oldversion = self.previous_version()
oldprofile = oldversion.get_profile(userid)
profile["has_old_version"] = oldprofile is not None
# Now, return it
return self.format_profile(userid, profile)
def new_profile_by_refid(self, refid: Optional[str], name: Optional[str]) -> Node:
"""
Given a RefID and an optional name, create a profile and then return
a formatted profile node. Similar rationale to get_profile_by_refid.
"""
if refid is None:
return None
if name is None:
name = "なし"
# First, create and save the default profile
userid = self.data.remote.user.from_refid(self.game, self.version, refid)
profile = Profile(
self.game,
self.version,
refid,
0,
{
"name": name,
},
)
self.put_profile(userid, profile)
# Now, reload and format the profile, looking up the has old version flag
oldversion = self.previous_version()
oldprofile = oldversion.get_profile(userid)
profile["has_old_version"] = oldprofile is not None
return self.format_profile(userid, profile)
def get_scores_by_extid(self, extid: Optional[int]) -> Optional[Node]:
"""
Given an ExtID, return a formatted score node. Similar rationale to
get_profile_by_refid.
"""
if extid is None:
return None
userid = self.data.remote.user.from_extid(self.game, self.version, extid)
scores = self.data.remote.music.get_scores(
self.game, self.music_version, userid
)
if scores is None:
return None
profile = self.get_profile(userid)
if profile is None:
return None
return self.format_scores(userid, profile, scores)
def update_score(
self,
userid: UserID,
timestamp: int,
songid: int,
chart: int,
points: int,
medal: int,
combo: int,
ghost: Optional[List[int]] = None,
stats: Optional[Dict[str, int]] = None,
music_rate: Optional[int] = None,
) -> None:
"""
Given various pieces of a score, update the user's high score and score
history in a controlled manner, so all games in Jubeat series can expect
the same attributes in a score.
"""
# Range check medals
if medal not in [
self.PLAY_MEDAL_FAILED,
self.PLAY_MEDAL_CLEARED,
self.PLAY_MEDAL_NEARLY_FULL_COMBO,
self.PLAY_MEDAL_FULL_COMBO,
self.PLAY_MEDAL_NEARLY_EXCELLENT,
self.PLAY_MEDAL_EXCELLENT,
]:
raise Exception(f"Invalid medal value {medal}")
oldscore = self.data.local.music.get_score(
self.game,
self.music_version,
userid,
songid,
chart,
)
# Score history is verbatum, instead of highest score
history = ValidatedDict({})
oldpoints = points
if oldscore is None:
# If it is a new score, create a new dictionary to add to
scoredata = ValidatedDict({})
raised = True
highscore = True
else:
# Set the score to any new record achieved
raised = points > oldscore.points
highscore = points >= oldscore.points
points = max(oldscore.points, points)
scoredata = oldscore.data
# Replace medal with highest value
scoredata.replace_int("medal", max(scoredata.get_int("medal"), medal))
history.replace_int("medal", medal)
# Increment counters based on medal
if medal == self.PLAY_MEDAL_CLEARED:
scoredata.increment_int("clear_count")
if medal == self.PLAY_MEDAL_FULL_COMBO:
scoredata.increment_int("full_combo_count")
if medal == self.PLAY_MEDAL_EXCELLENT:
scoredata.increment_int("excellent_count")
# If we have a combo, replace it
scoredata.replace_int("combo", max(scoredata.get_int("combo"), combo))
history.replace_int("combo", combo)
if stats is not None:
if raised:
# We have stats, and there's a new high score, update the stats
scoredata.replace_dict("stats", stats)
history.replace_dict("stats", stats)
if ghost is not None:
# Update the ghost regardless, but don't bother with it in history
scoredata.replace_int_array("ghost", len(ghost), ghost)
if music_rate is not None:
if oldscore is not None:
if music_rate > oldscore.data.get_int("music_rate"):
scoredata.replace_int("music_rate", music_rate)
else:
scoredata.replace_int("music_rate", music_rate)
history.replace_int("music_rate", music_rate)
# Look up where this score was earned
lid = self.get_machine_id()
# Write the new score back
self.data.local.music.put_score(
self.game,
self.music_version,
userid,
songid,
chart,
lid,
points,
scoredata,
highscore,
timestamp=timestamp,
)
# Save the history of this score too
self.data.local.music.put_attempt(
self.game,
self.music_version,
userid,
songid,
chart,
lid,
oldpoints,
history,
raised,
timestamp=timestamp,
)
def default_select_jbox(self) -> Set[int]:
gameitems = self.data.local.game.get_items(self.game, self.version)
default_main: Set[int] = set()
for gameitem in gameitems:
if gameitem.type == "emblem":
if (
gameitem.data.get_int("layer") == 2
and gameitem.data.get_int("rarity") == 1
):
default_main.add(gameitem.id)
return default_main
def random_select_jbox(self, owned_emblems: Set[int]) -> Tuple[int, int]:
gameitems = self.data.local.game.get_items(self.game, self.version)
normalemblems: Set[int] = set()
premiumemblems: Set[int] = set()
for gameitem in gameitems:
if gameitem.type == "emblem":
if gameitem.id in owned_emblems:
# We don't want to give out random emblems that are already owned.
continue
if gameitem.data.get_int("rarity") in {1, 2, 3}:
normalemblems.add(gameitem.id)
if gameitem.data.get_int("rarity") in {4, 5}:
premiumemblems.add(gameitem.id)
# If they've earned all the premium emblems, give them normal emblems instead.
if normalemblems and not premiumemblems:
premiumemblems = normalemblems
# Now, try to default to the default emblem, in the case that the person
# has earned every single part (unlikely).
if not normalemblems:
normalemblems = self.default_select_jbox()
if not premiumemblems:
premiumemblems = self.default_select_jbox()
# Default to some hand-picked emblems in case the catalog is not available.
normalindex = 2
premiumindex = 1
if normalemblems:
normalindex = random.sample(normalemblems, 1)[0]
if premiumemblems:
premiumindex = random.sample(premiumemblems, 1)[0]
return normalindex, premiumindex
def calculate_owned_items(self, item_list: List[int]) -> Set[int]:
owned_items: Set[int] = set()
for index in range(len(item_list) * 32):
offset = 1 << (index % 32)
bucket = index // 32
if (item_list[bucket] & offset) != 0:
owned_items.add(index)
return owned_items
def create_owned_items(self, items: Iterable[int], size: int) -> List[int]:
items_list = [0] * size
for index in items:
offset = 1 << (index % 32)
bucket = index // 32
items_list[bucket] |= offset
return [struct.unpack("i", struct.pack("I", item))[0] for item in items_list]