- 
+ 
+ 
| ||
| Front: | ||
| Back: | ||
| + | ||
{{ system_voices[profile.voiceId]["name"] if system_voices|length > 0 else "Server DB needs upgraded or is not populated with necessary data" }} |
{% endif %}
+ {% if cur_version >= 18 %}
+ ||
| Stage: | +{{ stages[profile.stageId]["name"] if stages|length > 0 else "Server DB needs upgraded or is not populated with necessary data" }} |
+ |
+
+ {% endif %}
+
+
+
+
+ {% for item in stages.values() %}
+ 
+
+ {% endfor %}
+
+ | Nameplate: | |
| Trophy: |
- |
| Trophy Sub 1: |
+
+ |
| Trophy Sub 2: |
+
+ |
| Character: | |
|
@@ -124,7 +143,10 @@ userbox_components = {
};
types = Object.keys(userbox_components);
orig_trophy = curr_trophy = "{{ profile.trophyId }}";
+orig_trophy_sub_1 = curr_trophy_sub_1 = "{{ profile.trophyIdSub1 }}";
+orig_trophy_sub_2 = curr_trophy_sub_2 = "{{ profile.trophyIdSub2 }}";
curr_trophy_img = "";
+curr_trophy_name = "";
function enableButtons(enabled) {
document.getElementById("reset-btn").disabled = !enabled;
@@ -159,16 +181,17 @@ function changeItem(type, id, name, img) {
function getRankImage(selected_rank) {
for (const x of Array(12).keys()) {
if (selected_rank.classList.contains("trophy-rank" + x.toString())) {
- return "rank" + x.toString() + ".png";
+ return "rank" + x.toString() + ".webp";
}
}
- return "rank0.png"; // shouldnt ever happen
+ return "rank0.webp"; // shouldnt ever happen
}
function changeTrophy() {
var trophy_element = document.getElementById("trophy");
curr_trophy = trophy_element.value;
+ curr_trophy_name = trophy_element[trophy_element.selectedIndex].innerText
curr_trophy_img = getRankImage(trophy_element[trophy_element.selectedIndex]);
updatePreview();
if (curr_trophy != orig_trophy) {
@@ -176,12 +199,38 @@ function changeTrophy() {
}
}
+function changeTrophySub1() {
+ var trophy_element = document.getElementById("trophy-sub-1");
+
+ curr_trophy_sub_1 = trophy_element.value;
+ curr_trophy_img = getRankImage(trophy_element[trophy_element.selectedIndex]);
+ curr_trophy_name = trophy_element[trophy_element.selectedIndex].innerText
+ updatePreview();
+ if (curr_trophy_sub_1 != orig_trophy_sub_1) {
+ enableButtons(true);
+ }
+}
+
+function changeTrophySub2() {
+ var trophy_element = document.getElementById("trophy-sub-2");
+
+ curr_trophy_sub_2 = trophy_element.value;
+ curr_trophy_img = getRankImage(trophy_element[trophy_element.selectedIndex]);
+ curr_trophy_name = trophy_element[trophy_element.selectedIndex].innerText
+ updatePreview();
+ if (curr_trophy_sub_2 != orig_trophy_sub_2) {
+ enableButtons(true);
+ }
+}
+
function resetUserbox() {
for (const type of types) {
changeItem(type, userbox_components[type][orig_id], userbox_components[type][orig_name], userbox_components[type][orig_img]);
}
// reset trophy
document.getElementById("trophy").value = orig_trophy;
+ document.getElementById("trophy-sub-1").value = orig_trophy_sub_1;
+ document.getElementById("trophy-sub-2").value = orig_trophy_sub_2;
changeTrophy();
// disable the save/reset buttons until something changes
enableButtons(false);
@@ -193,12 +242,14 @@ function updatePreview() {
document.getElementById("name_" + type).innerHTML = userbox_components[type][curr_name];
}
document.getElementById("preview_trophy_rank").src = "img/rank/" + curr_trophy_img;
- document.getElementById("preview_trophy_name").innerHTML = document.getElementById("trophy")[document.getElementById("trophy").selectedIndex].innerText;
+ document.getElementById("preview_trophy_name").innerHTML = curr_trophy_name;
}
function saveUserbox() {
$.post("/game/chuni/update.userbox", { nameplate: userbox_components["nameplate"][curr_id],
- trophy: curr_trophy,
+ trophy: curr_trophy,
+ trophySub1: curr_trophy_sub_1,
+ trophySub2: curr_trophy_sub_2,
character: userbox_components["character"][curr_id] })
.done(function (data) {
// set the current as the original and disable buttons
@@ -207,7 +258,9 @@ function saveUserbox() {
userbox_components[type][orig_name] = userbox_components[type][orig_name];
userbox_components[type][orig_img] = userbox_components[type][curr_img];
}
- orig_trophy = curr_trophy
+ orig_trophy = curr_trophy;
+ orig_trophy_sub_1 = curr_trophy_sub_1;
+ orig_trophy_sub_2 = curr_trophy_sub_2;
enableButtons(false);
})
.fail(function () {
diff --git a/titles/chuni/verse.py b/titles/chuni/verse.py
new file mode 100644
index 0000000..55a4058
--- /dev/null
+++ b/titles/chuni/verse.py
@@ -0,0 +1,281 @@
+from datetime import datetime, timedelta
+from typing import Dict, List, Set
+
+from core.config import CoreConfig
+from titles.chuni.config import ChuniConfig
+from titles.chuni.const import (
+ ChuniConstants,
+ MapAreaConditionLogicalOperator,
+ MapAreaConditionType,
+)
+from titles.chuni.luminous import MysticAreaConditions
+from titles.chuni.luminousplus import ChuniLuminousPlus
+
+
+class ChuniVerse(ChuniLuminousPlus):
+ def __init__(self, core_cfg: CoreConfig, game_cfg: ChuniConfig) -> None:
+ super().__init__(core_cfg, game_cfg)
+ self.version = ChuniConstants.VER_CHUNITHM_VERSE
+
+ async def handle_c_m_get_user_preview_api_request(self, data: Dict) -> Dict:
+ user_data = await super().handle_c_m_get_user_preview_api_request(data)
+
+ # Does CARD MAKER 1.35 work this far up?
+ user_data["lastDataVersion"] = "2.30.00"
+ return user_data
+
+ async def handle_get_game_map_area_condition_api_request(self, data: Dict) -> Dict:
+ # There is no game data for this, everything is server side.
+ # However, we can selectively show/hide events as data is imported into the server.
+ events = await self.data.static.get_enabled_events(self.version)
+ event_by_id = {evt["eventId"]: evt for evt in events}
+ conditions = []
+
+ mystic_conditions = MysticAreaConditions(
+ event_by_id,
+ 3230401,
+ self.date_time_format,
+ )
+
+ # Mystic Rainbow of VERSE - VERSE ep. I
+ mystic_conditions.add_condition(16006, 3020798, 3230402)
+
+ # Mystic Rainbow of VERSE - VERSE ep. II
+ mystic_conditions.add_condition(16204, 3020799, 3230403)
+
+ # Mystic Rainbow of VERSE - VERSE ep. III
+ mystic_conditions.add_condition(16455, 3020800, 3230404)
+
+ # Mystic Rainbow of VERSE - VERSE ep. IV
+ mystic_conditions.add_condition(16607, 3020802, 3230405)
+
+ conditions += mystic_conditions.conditions
+
+ return {
+ "length": len(conditions),
+ "gameMapAreaConditionList": conditions,
+ }
+
+ async def handle_get_game_course_level_api_request(self, data: Dict) -> Dict:
+ unlock_challenges = await self.data.static.get_unlock_challenges(self.version)
+ game_course_level_list = []
+
+ for unlock_challenge in unlock_challenges:
+ course_ids = [
+ unlock_challenge[f"courseId{i}"]
+ for i in range(1, 6)
+ if unlock_challenge[f"courseId{i}"] is not None
+ ]
+
+ start_date = unlock_challenge["startDate"].replace(
+ hour=0, minute=0, second=0
+ )
+
+ for i, course_id in enumerate(course_ids):
+ start = start_date + timedelta(days=7 * i)
+ end = start_date + timedelta(days=7 * (i + 1)) - timedelta(seconds=1)
+
+ if i == len(course_ids) - 1:
+ # If this is the last course, set end date to a far future date
+ end = datetime(2099, 1, 1)
+
+ game_course_level_list.append(
+ {
+ "courseId": course_id,
+ "startDate": start.strftime(self.date_time_format),
+ "endDate": end.strftime(self.date_time_format),
+ }
+ )
+
+ return {
+ "length": len(game_course_level_list),
+ "gameCourseLevelList": game_course_level_list,
+ }
+
+ async def handle_get_game_u_c_condition_api_request(self, data: Dict) -> Dict:
+ unlock_challenges = await self.data.static.get_unlock_challenges(self.version)
+ game_unlock_challenge_condition_list = []
+
+ conditions = {
+ # unlock Theatore Creatore (ULTIMA) after clearing map VERSE ep. I
+ 10001: {
+ "type": MapAreaConditionType.MAP_CLEARED.value,
+ "conditionId": 3020798,
+ },
+ # unlock Crossmythos Rhapsodia after clearing map VERSE ep. IV
+ 10006: {
+ "type": MapAreaConditionType.MAP_CLEARED.value,
+ "conditionId": 3020802,
+ },
+ }
+
+ for unlock_challenge in unlock_challenges:
+ unlock_challenge_id = unlock_challenge["unlockChallengeId"]
+
+ unlock_condition = conditions.get(
+ unlock_challenge_id,
+ # default is to unlock for players above 5.00 rating
+ {
+ "type": MapAreaConditionType.MINIMUM_RATING.value,
+ "conditionId": 500,
+ },
+ )
+
+ game_unlock_challenge_condition_list.append(
+ {
+ "unlockChallengeId": unlock_challenge_id,
+ "length": 1,
+ "conditionList": [
+ {
+ "type": unlock_condition["type"],
+ "conditionId": unlock_condition["conditionId"],
+ "logicalOpe": MapAreaConditionLogicalOperator.AND.value,
+ "startDate": unlock_challenge["startDate"].strftime(
+ self.date_time_format
+ ),
+ "endDate": datetime(2099, 1, 1).strftime(
+ self.date_time_format
+ ),
+ }
+ ],
+ }
+ )
+
+ return {
+ "length": len(game_unlock_challenge_condition_list),
+ "gameUnlockChallengeConditionList": game_unlock_challenge_condition_list,
+ }
+
+ async def handle_get_user_u_c_api_request(self, data: Dict) -> Dict:
+ user_id = data["userId"]
+
+ user_unlock_challenges = await self.data.item.get_unlock_challenges(
+ user_id, self.version
+ )
+
+ user_unlock_challenge_list = [
+ {
+ "unlockChallengeId": user_uc["unlockChallengeId"],
+ "status": user_uc["status"],
+ "clearCourseId": user_uc["clearCourseId"],
+ "conditionType": user_uc["conditionType"],
+ "score": user_uc["score"],
+ "life": user_uc["life"],
+ "clearDate": user_uc["clearDate"].strftime(self.date_time_format),
+ }
+ for user_uc in user_unlock_challenges
+ ]
+
+ return {
+ "userId": user_id,
+ "userUnlockChallengeList": user_unlock_challenge_list,
+ }
+
+ async def handle_get_user_rec_music_api_request(self, data: Dict) -> Dict:
+ rec_limit = 25 # limit for recommendations
+ user_id = data["userId"]
+ user_rec_music_set = set()
+
+ recent_rating = await self.data.profile.get_profile_recent_rating(user_id)
+ if not recent_rating:
+ # If no recent ratings, return an empty list
+ return {
+ "length": 0,
+ "userRecMusicList": [],
+ }
+
+ recent_ratings = recent_rating["recentRating"]
+ # cache music info
+ music_info_list = []
+
+ for recent_rating in recent_ratings:
+ music_id = recent_rating["musicId"]
+ music_info = await self.data.static.get_song(music_id)
+ if music_info:
+ music_info_list.append(music_info)
+
+ # use a set to avoid duplicates
+ user_rec_music_set = set()
+
+ # try adding recommendations in order of: title → artist → genre
+ for field in ("title", "artist", "genre"):
+ await self._add_recommendations(
+ field, user_rec_music_set, music_info_list, rec_limit
+ )
+ if len(user_rec_music_set) >= rec_limit:
+ break
+
+ user_rec_music_list = [
+ {
+ "musicId": 1, # a song the player recently played
+ # recMusicList is a semi colon-separated list of music IDs and their order comma separated
+ # for some reason, not all music ids are shown in game?!
+ "recMusicList": ";".join(
+ f"{music_id},{index + 1}"
+ for index, music_id in enumerate(user_rec_music_set)
+ ),
+ },
+ ]
+
+ return {
+ "length": len(user_rec_music_list),
+ "userRecMusicList": user_rec_music_list,
+ }
+
+ async def handle_get_user_rec_rating_api_request(self, data: Dict) -> Dict:
+ class GetUserRecRatingApi:
+ class UserRecRating:
+ ratingMin: int
+ ratingMax: int
+ # semicolon-delimited list of (musicId, level, sortingKey, score), in the
+ # same format as GetUserRecMusicApi
+ recMusicList: str
+
+ length: int
+ userRecRatingList: list[UserRecRating]
+
+ user_id = data["userId"]
+
+ user_rec_rating_list = []
+
+ return {
+ "length": len(user_rec_rating_list),
+ "userRecRatingList": user_rec_rating_list,
+ }
+
+ async def _add_recommendations(
+ self,
+ field: str,
+ user_rec_music_set: Set[int],
+ music_info_list: List[Dict],
+ limit: int = 25,
+ ) -> None:
+ """
+ Adds music recommendations based on a specific metadata field (title/artist/genre),
+ excluding music IDs already in the user's recent ratings and recommendations.
+ """
+ # Collect all existing songId to exclude from recommendations
+ existing_music_ids = {info["songId"] for info in music_info_list}
+
+ for music_info in music_info_list:
+ if len(user_rec_music_set) >= limit:
+ break
+
+ metadata_value = music_info[field]
+ if not metadata_value:
+ continue
+
+ recs = await self.data.static.get_music_by_metadata(
+ **{field: metadata_value}
+ )
+ for rec in recs or []:
+ song_id = rec["songId"]
+ # skip if the song is already in the user's recent ratings
+ # or if the song is already in the user's recommendations
+ if (
+ len(user_rec_music_set) >= limit
+ or song_id in existing_music_ids
+ or song_id in user_rec_music_set
+ ):
+ continue
+ user_rec_music_set.add(song_id)
diff --git a/titles/chuni/xverse.py b/titles/chuni/xverse.py
new file mode 100644
index 0000000..56f51d1
--- /dev/null
+++ b/titles/chuni/xverse.py
@@ -0,0 +1,317 @@
+import asyncio
+from datetime import datetime, timedelta, timezone
+from typing import Dict
+
+from core.config import CoreConfig
+
+from .config import ChuniConfig
+from .const import (
+ ChuniConstants,
+ LinkedVerseUnlockConditionType,
+ MapAreaConditionLogicalOperator,
+ MapAreaConditionType,
+)
+from .luminous import MysticAreaConditions
+from .verse import ChuniVerse
+
+
+class ChuniXVerse(ChuniVerse):
+ def __init__(self, core_cfg: CoreConfig, game_cfg: ChuniConfig) -> None:
+ super().__init__(core_cfg, game_cfg)
+ self.version = ChuniConstants.VER_CHUNITHM_X_VERSE
+
+ async def handle_c_m_get_user_preview_api_request(self, data: Dict) -> Dict:
+ user_data = await super().handle_c_m_get_user_preview_api_request(data)
+
+ # Does CARD MAKER 1.35 work this far up?
+ user_data["lastDataVersion"] = "2.40.00"
+ return user_data
+
+ async def handle_get_game_map_area_condition_api_request(self, data: Dict) -> Dict:
+ events = await self.data.static.get_enabled_events(self.version)
+
+ if events is None:
+ return {"length": 0, "gameMapAreaConditionList": []}
+
+ events_by_id = {event["eventId"]: event for event in events}
+ mystic_conditions = MysticAreaConditions(
+ events_by_id, 3239201, self.date_time_format
+ )
+
+ # Mystic Rainbow of X-VERSE Area 2 unlocks when VERSE ep. ORIGIN is finished.
+ mystic_conditions.add_condition(17021, 3020803, 3239202)
+
+ # Mystic Rainbow of X-VERSE Area 3 unlocks when VERSE ep. AIR is finished.
+ mystic_conditions.add_condition(17104, 3020804, 3239203)
+
+ # Mystic Rainbow of X-VERSE Area 4 unlocks when VERSE ep. STAR is finished.
+ mystic_conditions.add_condition(17208, 3020805, 3239204)
+
+ # Mystic Rainbow of X-VERSE Area 5 unlocks when VERSE ep. AMAZON is finished.
+ mystic_conditions.add_condition(17304, 3020806, 3239205)
+
+ # Mystic Rainbow of X-VERSE Area 6 unlocks when VERSE ep. CRYSTAL is finished.
+ mystic_conditions.add_condition(17407, 3020807, 3239206)
+
+ # Mystic Rainbow of X-VERSE Area 7 unlocks when VERSE ep. PARADISE is finished.
+ mystic_conditions.add_condition(17483, 3020808, 3239207)
+
+ return {
+ "length": len(mystic_conditions.conditions),
+ "gameMapAreaConditionList": mystic_conditions.conditions,
+ }
+
+ async def handle_get_game_course_level_api_request(self, data: Dict) -> Dict:
+ uc_likes = [] # includes both UCs and LVs, though the former doesn't show up at all in X-VERSE
+ unlock_challenges, linked_verses = await asyncio.gather(
+ self.data.static.get_unlock_challenges(self.version),
+ self.data.static.get_linked_verses(self.version),
+ )
+
+ if unlock_challenges:
+ uc_likes.extend(unlock_challenges)
+
+ if linked_verses:
+ uc_likes.extend(linked_verses)
+
+ if not uc_likes:
+ return {"length": 0, "gameCourseLevelList": []}
+
+ course_level_list = []
+ current_time = datetime.now(timezone.utc).replace(tzinfo=None)
+
+ for uc_like in uc_likes:
+ course_ids = [
+ uc_like[f"courseId{i}"]
+ for i in range(1, 6)
+ if uc_like[f"courseId{i}"] is not None
+ ]
+ event_start_date = uc_like["startDate"].replace(hour=0, minute=0, second=0)
+
+ for i, course_id in enumerate(course_ids):
+ start_date = event_start_date + timedelta(days=7 * i)
+
+ if i == len(course_ids) - 1:
+ end_date = datetime(2099, 12, 31, 23, 59, 59)
+ else:
+ end_date = (
+ event_start_date
+ + timedelta(days=7 * (i + 1))
+ - timedelta(seconds=1)
+ )
+
+ if start_date <= current_time <= end_date:
+ course_level_list.append(
+ {
+ "courseId": course_id,
+ "startDate": start_date.strftime(self.date_time_format),
+ "endDate": end_date.strftime(self.date_time_format),
+ }
+ )
+
+ return {
+ "length": len(course_level_list),
+ "gameCourseLevelList": course_level_list,
+ }
+
+ async def handle_get_game_l_v_condition_open_api_request(self, data: Dict) -> Dict:
+ linked_verses = await self.data.static.get_linked_verses(self.version)
+
+ if not linked_verses:
+ return {"length": 0, "gameLinkedVerseConditionOpenList": []}
+
+ linked_verse_by_id = {r["linkedVerseId"]: r for r in linked_verses}
+ conditions = []
+
+ for lv_id, map_id in [
+ (10001, 3020803), # ORIGIN
+ (10002, 3020804), # AIR
+ (10003, 3020805), # STAR
+ (10004, 3020806), # AMAZON
+ (10005, 3020807), # CRYSTAL
+ (10006, 3020808), # PARADISE
+ ]:
+ if (lv := linked_verse_by_id.get(lv_id)) is None:
+ continue
+
+ conditions.append(
+ {
+ "linkedVerseId": lv["linkedVerseId"],
+ "length": 1,
+ "conditionList": [
+ {
+ "type": MapAreaConditionType.MAP_CLEARED.value,
+ "conditionId": map_id,
+ "logicalOpe": MapAreaConditionLogicalOperator.AND.value,
+ "startDate": lv["startDate"].strftime(
+ self.date_time_format
+ ),
+ "endDate": "2099-12-31 23:59:59",
+ }
+ ],
+ }
+ )
+
+ return {
+ "length": len(conditions),
+ "gameLinkedVerseConditionOpenList": conditions,
+ }
+
+ async def handle_get_game_l_v_condition_unlock_api_request(
+ self, data: Dict
+ ) -> Dict:
+ linked_verses = await self.data.static.get_linked_verses(self.version)
+
+ if not linked_verses:
+ return {
+ "length": 0,
+ "gameLinkedVerseConditionUnlockList": [],
+ }
+
+ linked_verse_by_id = {r["linkedVerseId"]: r for r in linked_verses}
+ conditions = []
+
+ # For reference on official Linked VERSE conditions:
+ # https://docs.google.com/spreadsheets/d/1j7kmCR0-R5W3uivwkw-6A_eUCXttnJLnkTO0Qf7dya0/edit?usp=sharing
+
+ # Linked GATE ORIGIN - Play 30 ORIGIN Fables songs
+ if gate_origin := linked_verse_by_id.get(10001):
+ conditions.append(
+ {
+ "linkedVerseId": gate_origin["linkedVerseId"],
+ "length": 1,
+ "conditionList": [
+ {
+ "type": LinkedVerseUnlockConditionType.PLAY_SONGS.value,
+ "conditionList": "59;79;148;71;75;140;163;80;51;64;65;74;95;67;53;100;108;107;105;82;76;141;63;147;69;151;70;101;152;180",
+ "logicalOpe": MapAreaConditionLogicalOperator.AND.value,
+ "startDate": gate_origin["startDate"].strftime(
+ self.date_time_format
+ ),
+ "endDate": "2099-12-31 00:00:00",
+ }
+ ],
+ }
+ )
+
+ # Linked GATE AIR - Obtain class banner
+ if gate_air := linked_verse_by_id.get(10002):
+ conditions.append(
+ {
+ "linkedVerseId": gate_air["linkedVerseId"],
+ "length": 1,
+ "conditionList": [
+ {
+ "type": LinkedVerseUnlockConditionType.COURSE_CLEAR_AND_CLASS_EMBLEM.value,
+ "conditionList": "1_2_3_4_5_6",
+ "logicalOpe": MapAreaConditionLogicalOperator.AND.value,
+ "startDate": gate_air["startDate"].strftime(
+ self.date_time_format
+ ),
+ "endDate": "2099-12-31 00:00:00",
+ }
+ ],
+ }
+ )
+
+ # Linked GATE STAR - Obtain a trophy by leveling a character to level 15
+ if gate_star := linked_verse_by_id.get(10003):
+ conditions.append(
+ {
+ "linkedVerseId": gate_star["linkedVerseId"],
+ "length": 1,
+ "conditionList": [
+ {
+ "type": LinkedVerseUnlockConditionType.TROPHY_OBTAINED.value,
+ "conditionList": "9718",
+ "logicalOpe": MapAreaConditionLogicalOperator.AND.value,
+ "startDate": gate_star["startDate"].strftime(
+ self.date_time_format
+ ),
+ "endDate": "2099-12-31 00:00:00",
+ }
+ ],
+ }
+ )
+
+ # Linked GATE AMAZON - Play Killing Rhythm and Climax from the favorites folder
+ if gate_amazon := linked_verse_by_id.get(10004):
+ conditions.append(
+ {
+ "linkedVerseId": gate_amazon["linkedVerseId"],
+ "length": 1,
+ "conditionList": [
+ {
+ "type": LinkedVerseUnlockConditionType.PLAY_SONGS_IN_FAVORITE.value,
+ "conditionList": "712;777",
+ "logicalOpe": MapAreaConditionLogicalOperator.AND.value,
+ "startDate": gate_amazon["startDate"].strftime(
+ self.date_time_format
+ ),
+ "endDate": "2099-12-31 00:00:00",
+ }
+ ],
+ }
+ )
+
+ # Linked GATE CRYSTAL - Clear team course while equipping a character of minimum rank 26
+ if gate_crystal := linked_verse_by_id.get(10005):
+ conditions.append(
+ {
+ "linkedVerseId": gate_crystal["linkedVerseId"],
+ "length": 1,
+ "conditionList": [
+ {
+ "type": LinkedVerseUnlockConditionType.CLEAR_TEAM_COURSE_WITH_CHARACTER_OF_MINIMUM_RANK.value,
+ "conditionList": "26",
+ "logicalOpe": MapAreaConditionLogicalOperator.AND.value,
+ "startDate": gate_crystal["startDate"].strftime(
+ self.date_time_format
+ ),
+ "endDate": "2099-12-31 00:00:00",
+ }
+ ],
+ }
+ )
+
+ # Linked GATE PARADISE - Play one solo song by each of the artists in Inori
+ if gate_paradise := linked_verse_by_id.get(10006):
+ conditions.append(
+ {
+ "linkedVerseId": gate_paradise["linkedVerseId"],
+ "length": 1,
+ "conditionList": [
+ {
+ "type": LinkedVerseUnlockConditionType.PLAY_SONGS.value,
+ "conditionList": "180_384_2355;407_2353;788_629_600;2704;2050_2354",
+ "logicalOpe": MapAreaConditionLogicalOperator.AND.value,
+ "startDate": gate_paradise["startDate"].strftime(
+ self.date_time_format
+ ),
+ "endDate": "2099-12-31 00:00:00",
+ }
+ ],
+ }
+ )
+
+ return {
+ "length": len(conditions),
+ "gameLinkedVerseConditionUnlockList": conditions,
+ }
+
+ async def handle_get_user_l_v_api_request(self, data: Dict) -> Dict:
+ user_id = int(data["userId"])
+ rows = await self.data.item.get_linked_verse(user_id) or []
+ linked_verses = []
+
+ for row in rows:
+ data = row._asdict()
+ data.pop("id")
+ data.pop("user")
+
+ linked_verses.append(data)
+
+ return {
+ "userId": user_id,
+ "userLinkedVerseList": linked_verses,
+ }
diff --git a/titles/cm/read.py b/titles/cm/read.py
index 8a1bb84..5eb8632 100644
--- a/titles/cm/read.py
+++ b/titles/cm/read.py
@@ -208,7 +208,8 @@ class CardMakerReader(BaseReader):
"1.35": Mai2Constants.VER_MAIMAI_DX_FESTIVAL_PLUS,
"1.40": Mai2Constants.VER_MAIMAI_DX_BUDDIES,
"1.45": Mai2Constants.VER_MAIMAI_DX_BUDDIES_PLUS,
- "1.50": Mai2Constants.VER_MAIMAI_DX_PRISM
+ "1.50": Mai2Constants.VER_MAIMAI_DX_PRISM,
+ "1.55": Mai2Constants.VER_MAIMAI_DX_PRISM_PLUS
}
for root, dirs, files in os.walk(base_dir):
diff --git a/titles/diva/index.py b/titles/diva/index.py
index 01e5eeb..bbba473 100644
--- a/titles/diva/index.py
+++ b/titles/diva/index.py
@@ -100,7 +100,7 @@ class DivaServlet(BaseServlet):
try:
handler = getattr(self.base, f"handle_{bin_req_data['cmd']}_request")
- resp = handler(bin_req_data)
+ resp = await handler(bin_req_data)
except AttributeError as e:
self.logger.warning(f"Unhandled {bin_req_data['cmd']} request {e}")
diff --git a/titles/idac/index.py b/titles/idac/index.py
index 00d90b1..a55f891 100644
--- a/titles/idac/index.py
+++ b/titles/idac/index.py
@@ -166,8 +166,8 @@ class IDACServlet(BaseServlet):
resp = {
"status_code": "0",
# Only IPv4 is supported
- "host": self.game_config.server.matching_host,
- "port": self.game_config.server.matching_p2p,
+ "host": self.game_cfg.server.matching_host,
+ "port": self.game_cfg.server.matching_p2p,
"room_name": "INDTA",
"state": 1,
}
diff --git a/titles/idz/index.py b/titles/idz/index.py
index 0ff5b8d..a9d6775 100644
--- a/titles/idz/index.py
+++ b/titles/idz/index.py
@@ -22,6 +22,7 @@ class IDZServlet(BaseServlet):
def __init__(self, core_cfg: CoreConfig, cfg_dir: str) -> None:
super().__init__(core_cfg, cfg_dir)
self.game_cfg = IDZConfig()
+ self.rsa_keys: List[IDZKey] = []
if path.exists(f"{cfg_dir}/{IDZConstants.CONFIG_NAME}"):
self.game_cfg.update(
yaml.safe_load(open(f"{cfg_dir}/{IDZConstants.CONFIG_NAME}"))
@@ -38,8 +39,6 @@ class IDZServlet(BaseServlet):
backupCount=10,
)
- self.rsa_keys: List[IDZKey] = []
-
fileHandler.setFormatter(log_fmt)
consoleHandler = logging.StreamHandler()
@@ -79,7 +78,32 @@ class IDZServlet(BaseServlet):
return False
if len(game_cfg.rsa_keys) <= 0 or not game_cfg.server.aes_key:
- logging.getLogger("idz").error("IDZ: No RSA/AES keys! IDZ cannot start")
+ logger = logging.getLogger("idz")
+ if not hasattr(logger, "inited"):
+ log_fmt_str = "[%(asctime)s] IDZ | %(levelname)s | %(message)s"
+ log_fmt = logging.Formatter(log_fmt_str)
+ fileHandler = TimedRotatingFileHandler(
+ "{0}/{1}.log".format(core_cfg.server.log_dir, "idz"),
+ encoding="utf8",
+ when="d",
+ backupCount=10,
+ )
+
+ fileHandler.setFormatter(log_fmt)
+
+ consoleHandler = logging.StreamHandler()
+ consoleHandler.setFormatter(log_fmt)
+
+ logger.addHandler(fileHandler)
+ logger.addHandler(consoleHandler)
+
+ logger.setLevel(game_cfg.server.loglevel)
+ coloredlogs.install(
+ level=game_cfg.server.loglevel, logger=logger, fmt=log_fmt_str
+ )
+ logger.inited = True
+
+ logger.error("No RSA/AES keys! IDZ cannot start")
return False
return True
diff --git a/titles/idz/userdb.py b/titles/idz/userdb.py
index 089778a..83aeabd 100644
--- a/titles/idz/userdb.py
+++ b/titles/idz/userdb.py
@@ -53,28 +53,31 @@ class IDZUserDB:
async def connection_cb(self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter):
self.logger.debug(f"Connection made from {writer.get_extra_info('peername')[0]}")
+ sent_handshake = False
while True:
try:
- base = 0
+ if not sent_handshake:
+ base = 0
- for i in range(len(self.static_key) - 1):
- shift = 8 * i
- byte = self.static_key[i]
+ for i in range(len(self.static_key) - 1):
+ shift = 8 * i
+ byte = self.static_key[i]
- base |= byte << shift
+ base |= byte << shift
- rsa_key = random.choice(self.rsa_keys)
- key_enc: int = pow(base, rsa_key.e, rsa_key.N)
- result = (
- key_enc.to_bytes(0x40, "little")
- + struct.pack(" | |
| ID: | +{{ profile.user }} | +
|---|---|
| version: | @@ -86,6 +90,40 @@ |
+ 
+ 
+ 
+
+
+
+
| Id | +Name | +Rating | +Show | ++ |
|---|---|---|---|---|
| {{ rival.2 }} | +{{ rival.0 }} | +{{ rival.1 }} | +
+
+
+
+ |
+ + + | +