robob/PyTaiko
1
0
Fork 0
mirror of https://github.com/Yonokid/PyTaiko.git synced 2026-02-04 11:40:13 +01:00
Code Issues Packages Projects Releases Wiki Activity

Compare commits

base: robob:5a5f9d9d0d25a29cd2e27c3a4c173197e30a54db
Branches Tags
robob:main robob:legacy-audio robob:keyboard-fix
robob:v1.1 robob:latest
..
compare: robob:keyboard-fix
Branches Tags
robob:main robob:legacy-audio robob:keyboard-fix
robob:v1.1 robob:latest

1 Commits
5a5f9d9d0d ... keyboard-f

Author SHA1 Message Date
Yonokid
d8a219243c unlikely fix 2026-01-01 10:56:55 -05:00
20 changed files with 420 additions and 1111 deletions
Expand all files Collapse all files

16
PyTaiko.py
View File

@@ -17,10 +17,10 @@ from raylib.defines import (
from libs.audio import audio
from libs.config import get_config
from libs.global_data import Difficulty, PlayerNum, ScoreMethod
from libs.global_data import PlayerNum, ScoreMethod
from libs.screen import Screen
from libs.song_hash import DB_VERSION
from libs.parsers.tja import TJAParser
from libs.tja import TJAParser
from libs.utils import (
force_dedicated_gpu,
get_current_ms,
@@ -263,12 +263,9 @@ def check_args():
if args.difficulty not in tja.metadata.course_data.keys():
parser.error(f"Invalid difficulty: {args.difficulty}. Available: {list(tja.metadata.course_data.keys())}")
selected_difficulty = args.difficulty
else:
if not tja.metadata.course_data:
selected_difficulty = Difficulty.EASY
else:
selected_difficulty = max(tja.metadata.course_data.keys())
current_screen = Screens.GAME_PRACTICE if args.practice else Screens.GAME
current_screen = Screens.GAME_PRACTICE if args.practice else Screens.AI_GAME
global_data.session_data[PlayerNum.P1].selected_song = path
global_data.session_data[PlayerNum.P1].selected_difficulty = selected_difficulty
global_data.modifiers[PlayerNum.P1].auto = args.auto
@@ -289,15 +286,14 @@ def check_discord_heartbeat(current_screen):
def draw_fps(last_fps: int):
curr_fps = ray.GetFPS()
pos = 20 * global_tex.screen_scale
if curr_fps != 0 and curr_fps != last_fps:
last_fps = curr_fps
if last_fps < 30:
pyray.draw_text_ex(global_data.font, f'{last_fps} FPS', (pos, pos), pos, 1, pyray.RED)
ray.DrawText(f'{last_fps} FPS'.encode('utf-8'), 20, 20, 20, ray.RED)
elif last_fps < 60:
pyray.draw_text_ex(global_data.font, f'{last_fps} FPS', (pos, pos), pos, 1, pyray.YELLOW)
ray.DrawText(f'{last_fps} FPS'.encode('utf-8'), 20, 20, 20, ray.YELLOW)
else:
pyray.draw_text_ex(global_data.font, f'{last_fps} FPS', (pos, pos), pos, 1, pyray.LIME)
ray.DrawText(f'{last_fps} FPS'.encode('utf-8'), 20, 20, 20, ray.LIME)
def draw_outer_border(screen_width: int, screen_height: int, last_color: pyray.Color):
pyray.draw_rectangle(-screen_width, 0, screen_width, screen_height, last_color)

2
Skins/PyTaikoGreen

Submodule Skins/PyTaikoGreen updated: 1829a2538b...ccd048aa2d

1
Songs/15 Recently Played/song_list.txt Normal file
View File

@@ -0,0 +1 @@
61506649d1a0f78c7759ffd83b010e58ab0e167bdeb06b11584933d7a7409f35|Dogbite|t+pazolite

2
config.toml
View File

@@ -2,7 +2,7 @@
fps_counter = false
audio_offset = 0
visual_offset = 0
language = "en"
language = "ja"
timer_frozen = true
judge_counter = false
nijiiro_notes = false

171
libs/file_navigator.py
View File

@@ -14,9 +14,8 @@ from raylib import SHADER_UNIFORM_VEC3
from libs.animation import Animation, MoveAnimation
from libs.audio import audio
from libs.global_data import Crown, Difficulty, ScoreMethod
from libs.parsers.osz import OsuParser
from libs.texture import tex
from libs.parsers.tja import TJAParser, test_encodings
from libs.tja import TJAParser, test_encodings
from libs.utils import OutlinedText, get_current_ms, global_data
BOX_CENTER = 594 * tex.screen_scale
@@ -209,13 +208,13 @@ class BackBox(BaseBox):
self.yellow_box.draw(self, fade_override, is_ura, self.name)
class SongBox(BaseBox):
def __init__(self, name: str, back_color: Optional[tuple[int, int, int]], fore_color: Optional[tuple[int, int, int]], texture_index: TextureIndex, tja: TJAParser | OsuParser):
def __init__(self, name: str, back_color: Optional[tuple[int, int, int]], fore_color: Optional[tuple[int, int, int]], texture_index: TextureIndex, tja: TJAParser):
super().__init__(name, back_color, fore_color, texture_index)
self.scores = dict()
self.hash = dict()
self.score_history = None
self.history_wait = 0
self.parser = tja
self.tja = tja
self.is_favorite = False
self.yellow_box = None
@@ -227,8 +226,8 @@ class SongBox(BaseBox):
with sqlite3.connect(global_data.score_db) as con:
cursor = con.cursor()
# Batch database query for all diffs at once
if self.parser.metadata.course_data:
hash_values = [self.hash[diff] for diff in self.parser.metadata.course_data if diff in self.hash]
if self.tja.metadata.course_data:
hash_values = [self.hash[diff] for diff in self.tja.metadata.course_data if diff in self.hash]
placeholders = ','.join('?' * len(hash_values))
batch_query = f"""
@@ -240,7 +239,7 @@ class SongBox(BaseBox):
hash_to_score = {row[0]: row[1:] for row in cursor.fetchall()}
for diff in self.parser.metadata.course_data:
for diff in self.tja.metadata.course_data:
if diff not in self.hash:
continue
diff_hash = self.hash[diff]
@@ -262,7 +261,7 @@ class SongBox(BaseBox):
self.score_history = ScoreHistory(self.scores, current_time)
if not is_open_prev and self.is_open:
self.yellow_box = YellowBox(False, tja=self.parser)
self.yellow_box = YellowBox(False, tja=self.tja)
self.yellow_box.create_anim()
self.wait = current_time
if current_time >= self.history_wait + 3000:
@@ -276,7 +275,7 @@ class SongBox(BaseBox):
self.name.draw(outline_color=self.fore_color, x=x + tex.skin_config["song_box_name"].x - int(self.name.texture.width / 2), y=y+tex.skin_config["song_box_name"].y, y2=min(self.name.texture.height, tex.skin_config["song_box_name"].height)-self.name.texture.height, fade=outer_fade_override)
if self.parser.ex_data.new:
if self.tja.ex_data.new:
tex.draw_texture('yellow_box', 'ex_data_new_song_balloon', x=x, y=y, fade=outer_fade_override)
valid_scores = {k: v for k, v in self.scores.items() if v is not None}
if valid_scores:
@@ -298,46 +297,6 @@ class SongBox(BaseBox):
if self.score_history is not None and get_current_ms() >= self.history_wait + 3000:
self.score_history.draw()
class SongBoxOsu(SongBox):
def update(self, current_time: float, is_diff_select: bool):
super().update(current_time, is_diff_select)
is_open_prev = self.is_open
self.is_open = self.position == BOX_CENTER
if self.yellow_box is not None:
self.yellow_box.update(is_diff_select)
if self.history_wait == 0:
self.history_wait = current_time
if self.score_history is None and {k: v for k, v in self.scores.items() if v is not None}:
self.score_history = ScoreHistory(self.scores, current_time)
if not is_open_prev and self.is_open:
self.yellow_box = YellowBox(False)
self.yellow_box.create_anim()
self.wait = current_time
if current_time >= self.history_wait + 3000:
self.history_wait = current_time
if self.score_history is not None:
self.score_history.update(current_time)
def _draw_closed(self, x: float, y: float, outer_fade_override: float):
super()._draw_closed(x, y, outer_fade_override)
self.name.draw(outline_color=self.fore_color, x=x + tex.skin_config["song_box_name"].x - int(self.name.texture.width / 2), y=y+tex.skin_config["song_box_name"].y, y2=min(self.name.texture.height, tex.skin_config["song_box_name"].height)-self.name.texture.height, fade=outer_fade_override)
valid_scores = {k: v for k, v in self.scores.items() if v is not None}
if valid_scores:
highest_key = max(valid_scores.keys())
score = self.scores[highest_key]
if score and score[5] == Crown.DFC:
tex.draw_texture('yellow_box', 'crown_dfc', x=x, y=y, frame=min(Difficulty.URA, highest_key), fade=outer_fade_override)
elif score and score[5] == Crown.FC:
tex.draw_texture('yellow_box', 'crown_fc', x=x, y=y, frame=min(Difficulty.URA, highest_key), fade=outer_fade_override)
elif score and score[5] >= Crown.CLEAR:
tex.draw_texture('yellow_box', 'crown_clear', x=x, y=y, frame=min(Difficulty.URA, highest_key), fade=outer_fade_override)
class FolderBox(BaseBox):
def __init__(self, name: str, back_color: Optional[tuple[int, int, int]], fore_color: Optional[tuple[int, int, int]], texture_index: TextureIndex, genre_index: GenreIndex, tja_count: int = 0, box_texture: Optional[str] = None):
super().__init__(name, back_color, fore_color, texture_index)
@@ -428,20 +387,12 @@ class FolderBox(BaseBox):
tex.draw_texture('yellow_box', 'song_count_songs', color=color)
dest_width = min(tex.skin_config["song_tja_count"].width, self.tja_count_text.texture.width)
self.tja_count_text.draw(outline_color=ray.BLACK, x=tex.skin_config["song_tja_count"].x - (dest_width//2), y=tex.skin_config["song_tja_count"].y, x2=dest_width-self.tja_count_text.texture.width, color=color)
if self.texture_index != TextureIndex.DEFAULT and self.box_texture is None:
if self.texture_index != TextureIndex.DEFAULT:
tex.draw_texture('box', 'folder_graphic', color=color, frame=self.genre_index)
tex.draw_texture('box', 'folder_text', color=color, frame=self.genre_index)
elif self.box_texture is not None:
scaled_width = self.box_texture.width * tex.screen_scale
scaled_height = self.box_texture.height * tex.screen_scale
max_width = 344 * tex.screen_scale
max_height = 424 * tex.screen_scale
if scaled_width > max_width or scaled_height > max_height:
width_scale = max_width / scaled_width
height_scale = max_height / scaled_height
scale_factor = min(width_scale, height_scale)
scaled_width *= scale_factor
scaled_height *= scale_factor
x = int((x + tex.skin_config["box_texture"].x) - (scaled_width // 2))
y = int((y + tex.skin_config["box_texture"].y) - (scaled_height // 2))
src = ray.Rectangle(0, 0, self.box_texture.width, self.box_texture.height)
@@ -450,7 +401,7 @@ class FolderBox(BaseBox):
class YellowBox:
"""A song box when it is opened."""
def __init__(self, is_back: bool, tja: Optional[TJAParser | OsuParser] = None, is_dan: bool = False):
def __init__(self, is_back: bool, tja: Optional[TJAParser] = None, is_dan: bool = False):
self.is_diff_select = False
self.is_back = is_back
self.tja = tja
@@ -1110,23 +1061,12 @@ class SongFile(FileSystemItem):
def __init__(self, path: Path, name: str, back_color: Optional[tuple[int, int, int]], fore_color: Optional[tuple[int, int, int]], texture_index: TextureIndex):
super().__init__(path, name)
self.is_recent = (datetime.now() - datetime.fromtimestamp(path.stat().st_mtime)) <= timedelta(days=7)
self.parser = TJAParser(path)
self.tja = TJAParser(path)
if self.is_recent:
self.parser.ex_data.new = True
title = self.parser.metadata.title.get(global_data.config['general']['language'].lower(), self.parser.metadata.title['en'])
self.tja.ex_data.new = True
title = self.tja.metadata.title.get(global_data.config['general']['language'].lower(), self.tja.metadata.title['en'])
self.hash = global_data.song_paths[path]
self.box = SongBox(title, back_color, fore_color, texture_index, self.parser)
self.box.hash = global_data.song_hashes[self.hash][0]["diff_hashes"]
self.box.get_scores()
class SongFileOsu(FileSystemItem):
def __init__(self, path: Path, name: str, back_color: Optional[tuple[int, int, int]], fore_color: Optional[tuple[int, int, int]], texture_index: TextureIndex):
super().__init__(path, name)
self.is_recent = (datetime.now() - datetime.fromtimestamp(path.stat().st_mtime)) <= timedelta(days=7)
self.parser = OsuParser(path)
title = self.parser.osu_metadata["Version"]
self.hash = global_data.song_paths[path]
self.box = SongBoxOsu(title, back_color, fore_color, texture_index, self.parser)
self.box = SongBox(title, back_color, fore_color, texture_index, self.tja)
self.box.hash = global_data.song_hashes[self.hash][0]["diff_hashes"]
self.box.get_scores()
@@ -1182,7 +1122,7 @@ class FileNavigator:
# Pre-generated objects storage
self.all_directories: dict[str, Directory] = {} # path -> Directory
self.all_song_files: dict[str, Union[SongFile, DanCourse, SongFileOsu]] = {} # path -> SongFile
self.all_song_files: dict[str, Union[SongFile, DanCourse]] = {} # path -> SongFile
self.directory_contents: dict[str, list[Union[Directory, SongFile]]] = {} # path -> list of items
# OPTION 2: Lazy crown calculation with caching
@@ -1322,10 +1262,6 @@ class FileNavigator:
child_dirs = []
for item_path in dir_path.iterdir():
if item_path.is_dir():
child_has_osu = any(item_path.glob("*.osu"))
if child_has_osu:
child_dirs.append(item_path)
self.process_osz(item_path)
child_has_box_def = (item_path / "box.def").exists()
if child_has_box_def:
child_dirs.append(item_path)
@@ -1353,8 +1289,8 @@ class FileNavigator:
elif song_key not in self.all_song_files and tja_path in global_data.song_paths:
song_obj = SongFile(tja_path, tja_path.name, back_color, fore_color, texture_index)
song_obj.box.get_scores()
for course in song_obj.parser.metadata.course_data:
level = song_obj.parser.metadata.course_data[course].level
for course in song_obj.tja.metadata.course_data:
level = song_obj.tja.metadata.course_data[course].level
scores = song_obj.box.scores.get(course)
if scores is not None:
@@ -1406,61 +1342,6 @@ class FileNavigator:
logger.error(f"Error creating SongFile for {tja_path}: {e}")
continue
def process_osz(self, dir_path: Path):
dir_key = str(dir_path)
if dir_path.iterdir():
name = dir_path.name
for file in dir_path.iterdir():
if file.name.endswith('.osu'):
with open(file, 'r', encoding='utf-8') as f:
content = f.readlines()
for line in content:
if line.startswith('TitleUnicode:'):
title_unicode = line.split(':', 1)[1].strip()
name = title_unicode
break
else:
name = dir_path.name if dir_path.name else str(dir_path)
box_texture = None
collection = None
back_color = None
fore_color = None
texture_index = TextureIndex.DEFAULT
genre_index = GenreIndex.DEFAULT
for file in dir_path.iterdir():
if file.name.endswith('.jpg') or file.name.endswith('.png'):
box_texture = str(file)
# Create Directory object
file_count = len([file for file in dir_path.glob("*.osu")])
directory_obj = Directory(
dir_path, name, back_color, fore_color, texture_index, genre_index,
tja_count=file_count,
box_texture=box_texture,
collection=collection,
)
self.all_directories[dir_key] = directory_obj
content_items = []
osu_files = [file for file in dir_path.glob("*.osu")]
# Create SongFile objects
for osu_path in sorted(osu_files):
song_key = str(osu_path)
if song_key not in self.all_song_files and osu_path in global_data.song_paths:
song_obj = SongFileOsu(osu_path, osu_path.name, back_color, fore_color, texture_index)
song_obj.box.get_scores()
self.song_count += 1
global_data.song_progress = self.song_count / global_data.total_songs
self.all_song_files[song_key] = song_obj
if song_key in self.all_song_files:
content_items.append(self.all_song_files[song_key])
self.directory_contents[dir_key] = content_items
def is_at_root(self) -> bool:
"""Check if currently at the virtual root"""
return self.current_dir == Path()
@@ -1496,7 +1377,7 @@ class FileNavigator:
if sibling_key in self.directory_contents:
for item in self.directory_contents[sibling_key]:
if isinstance(item, SongFile) and item:
if self.diff_sort_diff in item.parser.metadata.course_data and item.parser.metadata.course_data[self.diff_sort_diff].level == self.diff_sort_level:
if self.diff_sort_diff in item.tja.metadata.course_data and item.tja.metadata.course_data[self.diff_sort_diff].level == self.diff_sort_level:
if item not in content_items:
content_items.append(item)
return content_items
@@ -1544,7 +1425,7 @@ class FileNavigator:
if self._levenshtein_distance(song.name[:-4].lower(), search_name.lower()) < 2:
items.append(song)
if isinstance(song, SongFile):
if self._levenshtein_distance(song.parser.metadata.subtitle["en"].lower(), search_name.lower()) < 2:
if self._levenshtein_distance(song.tja.metadata.subtitle["en"].lower(), search_name.lower()) < 2:
items.append(song)
return items
@@ -1903,7 +1784,7 @@ class FileNavigator:
else:
box.draw(box.position + int(move_away_attribute), tex.skin_config["boxes"].y, is_ura, inner_fade_override=diff_fade_out_attribute, outer_fade_override=fade)
def mark_crowns_dirty_for_song(self, song_file: SongFile | SongFileOsu):
def mark_crowns_dirty_for_song(self, song_file: SongFile):
"""Mark directories as needing crown recalculation when a song's score changes"""
song_path = song_file.path
@@ -1966,7 +1847,7 @@ class FileNavigator:
return
recents_path = self.recent_folder.path / 'song_list.txt'
new_entry = f'{song.hash}|{song.parser.metadata.title["en"]}|{song.parser.metadata.subtitle["en"]}\n'
new_entry = f'{song.hash}|{song.tja.metadata.title["en"]}|{song.tja.metadata.subtitle["en"]}\n'
existing_entries = []
if recents_path.exists():
with open(recents_path, 'r', encoding='utf-8-sig') as song_list:
@@ -1977,7 +1858,7 @@ class FileNavigator:
with open(recents_path, 'w', encoding='utf-8-sig') as song_list:
song_list.writelines(recent_entries)
logger.info(f"Added Recent: {song.hash} {song.parser.metadata.title['en']} {song.parser.metadata.subtitle['en']}")
logger.info(f"Added Recent: {song.hash} {song.tja.metadata.title['en']} {song.tja.metadata.subtitle['en']}")
def add_favorite(self) -> bool:
"""Add the current song to the favorites list"""
@@ -1996,7 +1877,7 @@ class FileNavigator:
if not line: # Skip empty lines
continue
hash, title, subtitle = line.split('|')
if song.hash == hash or (song.parser.metadata.title['en'] == title and song.parser.metadata.subtitle['en'] == subtitle):
if song.hash == hash or (song.tja.metadata.title['en'] == title and song.tja.metadata.subtitle['en'] == subtitle):
if not self.in_favorites:
return False
else:
@@ -2005,11 +1886,11 @@ class FileNavigator:
with open(favorites_path, 'w', encoding='utf-8-sig') as song_list:
for line in lines:
song_list.write(line + '\n')
logger.info(f"Removed Favorite: {song.hash} {song.parser.metadata.title['en']} {song.parser.metadata.subtitle['en']}")
logger.info(f"Removed Favorite: {song.hash} {song.tja.metadata.title['en']} {song.tja.metadata.subtitle['en']}")
else:
with open(favorites_path, 'a', encoding='utf-8-sig') as song_list:
song_list.write(f'{song.hash}|{song.parser.metadata.title["en"]}|{song.parser.metadata.subtitle["en"]}\n')
logger.info(f"Added Favorite: {song.hash} {song.parser.metadata.title['en']} {song.parser.metadata.subtitle['en']}")
song_list.write(f'{song.hash}|{song.tja.metadata.title["en"]}|{song.tja.metadata.subtitle["en"]}\n')
logger.info(f"Added Favorite: {song.hash} {song.tja.metadata.title['en']} {song.tja.metadata.subtitle['en']}")
return True
navigator = FileNavigator()

311
libs/parsers/osz.py
View File

@@ -1,311 +0,0 @@
import hashlib
import math
from pathlib import Path
from libs.parsers.tja import CourseData, Note, NoteType, Drumroll, Balloon, NoteList, TJAEXData, TJAMetadata, TimelineObject
import re
class OsuParser:
general: dict[str, str]
editor: dict[str, str]
osu_metadata: dict[str, str]
difficulty: dict[str, str]
events: list[list[float]]
timing_points: list[list[float]]
hit_objects: list[list[float]]
bpm: list[float]
def __init__(self, osu_file: Path):
self.general = self.read_osu_data_dict(osu_file, target_header="General")
self.editor = self.read_osu_data_dict(osu_file, target_header="Editor")
self.osu_metadata = self.read_osu_data_dict(osu_file, target_header="Metadata")
self.difficulty = self.read_osu_data_dict(osu_file, target_header="Difficulty")
self.events = self.read_osu_data_list(osu_file, target_header="Events")
self.timing_points = self.read_osu_data_list(osu_file, target_header="TimingPoints")
#self.general = self.read_osu_data(osu_file, target_header="Colours", is_dict=True)
self.hit_objects = self.read_osu_data_list(osu_file, target_header="HitObjects")
self.slider_multiplier = float(self.difficulty["SliderMultiplier"])
self.metadata = TJAMetadata()
self.metadata.wave = osu_file.parent / self.general["AudioFilename"]
self.metadata.demostart = float(self.general["PreviewTime"]) / 1000
self.metadata.offset = -30/1000
self.metadata.title["en"] = self.osu_metadata["Version"]
self.metadata.subtitle["en"] = self.osu_metadata["Creator"]
match = re.search(r'\[Events\][\s\S]*?^[ \t]*(\d+),(\d+),"([^"]+)"', osu_file.read_text(), re.MULTILINE)
if match:
self.metadata.bgmovie = osu_file.parent / Path(match.group(3))
self.metadata.course_data[0] = CourseData()
self.ex_data = TJAEXData()
self.bpm = []
for points in self.timing_points:
self.bpm.append(math.floor(1 / points[1] * 1000 * 60))
self.osu_NoteList = self.note_data_to_NoteList(self.hit_objects)
for points in self.timing_points:
if points[1] > 0:
obj = TimelineObject()
obj.hit_ms = points[0]
obj.bpm = math.floor(1 / points[1] * 1000 * 60)
self.osu_NoteList[0].timeline.append(obj)
def read_osu_data_list(self, file_path: Path, target_header="HitObjects") -> list[list[float]]:
data = []
current_header = None
with file_path.open(mode='r', encoding='utf-8') as f:
for line in f:
line = line.rstrip("\n")
if re.match(r"\[\w*\]", line): # header pattern
current_header = line[1:-1]
if current_header == target_header:
if re.match(r"[-+]?\d*\.?\d+" , line): # Events, TimingPoints, HitObjects
string_array = re.findall(r"[-+]?\d*\.?\d+" , line) # search for floats
int_array = [float(num_str) for num_str in string_array]
data.append(int_array)
else:
continue
return data
def read_osu_data_dict(self, file_path: Path, target_header="HitObjects") -> dict[str, str]:
data = dict()
current_header = None
with file_path.open(mode='r', encoding='utf-8') as f:
for line in f:
line = line.rstrip("\n")
if re.match(r"\[\w*\]", line): # header pattern
current_header = line[1:-1]
if current_header == target_header:
if ':' in line and not line.startswith('['):
key, value = line.split(':', 1)
data[key.strip()] = value.strip()
else:
continue
return data
def get_scroll_multiplier(self, ms: float) -> float:
base_scroll = (1.0 if 1.37 <= self.slider_multiplier <= 1.47
else self.slider_multiplier / 1.40)
current_scroll = 1.0
for tp in self.timing_points:
time = tp[0]
beat_length = tp[1] # positive for BPM, negative for scroll
if time > ms:
break
if beat_length < 0: # This is an inherited (green) timing point
current_scroll = -100.0 / beat_length
return current_scroll * base_scroll
def note_data_to_NoteList(self, note_data) -> tuple[NoteList, list[NoteList], list[NoteList], list[NoteList]]:
osu_NoteList = NoteList()
counter = 0
for line in note_data:
note_time = line[2]
scroll = self.get_scroll_multiplier(note_time)
if (line[3] == 1 or line[3] == 4 or line[3] == 5 or line[3] == 6) and line[4] == 0: # DON
don = Note()
don.type = NoteType(1)
don.hit_ms = line[2]
don.bpm = self.bpm[0]
don.scroll_x = scroll
don.scroll_y = 0
don.display = True
don.index = counter
counter = counter + 1
don.moji = 1
osu_NoteList.play_notes.append(don)
if (line[3] == 1 or line[3] == 4 or line[3] == 5 or line[3] == 6) and (line[4] == 2 or line[4] == 8): # KAT
kat = Note()
kat.type = NoteType(2)
kat.hit_ms = line[2]
kat.bpm = self.bpm[0]
kat.scroll_x = scroll
kat.scroll_y = 0
kat.display = True
kat.index = counter
counter = counter + 1
kat.moji = 4
osu_NoteList.play_notes.append(kat)
if (line[3] == 1 or line[3] == 4 or line[3] == 5 or line[3] == 6) and line[4] == 4: # L-DON
don = Note()
don.type = NoteType(3)
don.hit_ms = line[2]
don.bpm = self.bpm[0]
don.scroll_x = scroll
don.scroll_y = 0
don.display = True
don.index = counter
counter = counter + 1
don.moji = 5
osu_NoteList.play_notes.append(don)
if (line[3] == 1 or line[3] == 4 or line[3] == 5 or line[3] == 6) and (line[4] == 6 or line[4] == 12): # L-KAT
kat = Note()
kat.type = NoteType(4)
kat.hit_ms = line[2]
kat.bpm = self.bpm[0]
kat.scroll_x = scroll
kat.scroll_y = 0
kat.display = True
kat.index = counter
counter = counter + 1
kat.moji = 6
osu_NoteList.play_notes.append(kat)
if (line[3] == 2) and (line[4] == 0): # Drum Roll
if len(line) >= 9:
slider_time = line[8] / (float(self.difficulty["SliderMultiplier"]) * 100) * self.timing_points[0][1]
else:
slider_time = line[6] / (float(self.difficulty["SliderMultiplier"]) * 100) * self.timing_points[0][1]
source = Note()
source.type = NoteType(8)
source.hit_ms = line[2] + slider_time
source.bpm = self.bpm[0]
source.scroll_x = scroll
source.scroll_y = 0
source.display = True
# this is where the index would be if it wasn't a tail note
source.moji = 7
slider = Drumroll(source)
slider.color = 255
slider.type = NoteType(5)
slider.hit_ms = line[2]
slider.bpm = self.bpm[0]
slider.scroll_x = scroll
slider.scroll_y = 0
slider.display = True
slider.index = counter
slider.moji = 10
counter = counter + 1
source.index = counter
counter = counter + 1
osu_NoteList.play_notes.append(slider)
osu_NoteList.play_notes.append(source)
if (line[3] == 2) and (line[4] == 4): # L-Drum Roll
if len(line) >= 9:
slider_time = line[8] / (float(self.difficulty["SliderMultiplier"]) * 100) * self.timing_points[0][1]
else:
slider_time = line[6] / (float(self.difficulty["SliderMultiplier"]) * 100) * self.timing_points[0][1]
source = Note()
source.type = NoteType(8)
source.hit_ms = line[2] + slider_time
source.bpm = self.bpm[0]
source.scroll_x = scroll
source.scroll_y = 0
source.display = True
# this is where the index would be if it wasn't a tail note
source.moji = 8
slider = Drumroll(source)
slider.color = 255
slider.type = NoteType(6)
slider.hit_ms = line[2]
slider.bpm = self.bpm[0]
slider.scroll_x = scroll
slider.scroll_y = 0
slider.display = True
slider.index = counter
counter = counter + 1
source.index = counter
counter = counter + 1
osu_NoteList.play_notes.append(slider)
osu_NoteList.play_notes.append(source)
if (line[3] == 8): # Balloon
source = Note()
source.type = NoteType(8)
source.hit_ms = line[5]
source.bpm = self.bpm[0]
source.scroll_x = scroll
source.scroll_y = 0
source.display = True
#source.index = counter
#counter = counter + 1
source.moji = 9
balloon = Balloon(source)
balloon.type = NoteType(7)
balloon.hit_ms = line[2]
balloon.bpm = self.bpm[0]
balloon.scroll_x = scroll
balloon.scroll_y = 0
balloon.display = True
balloon.index = counter
counter = counter + 1
balloon.moji = 10
'''
od = int(self.difficulty["OverallDifficulty"])
# thank you https://github.com/IepIweidieng/osu2tja/blob/dev-iid/osu2tja/osu2tja.py
hit_multiplier = (5 - 2 * (5 - od) / 5 if od < 5
else 5 + 2.5 * (od - 5) / 5 if od > 5
else 5) * 1.65
'''
balloon.count = 20#int(max(1, (ret[-1][1] - ret[-2][1]) / 1000 * hit_multiplier))
# end of 'stolen' code
source.index = counter
counter = counter + 1
osu_NoteList.play_notes.append(balloon)
osu_NoteList.play_notes.append(source)
osu_NoteList.draw_notes = osu_NoteList.play_notes.copy()
return osu_NoteList, [], [], []
def notes_to_position(self, difficulty):
return self.osu_NoteList
def hash_note_data(self, notes: NoteList):
"""Hashes the note data for the given NoteList."""
n = hashlib.sha256()
list1 = notes.play_notes
list2 = notes.bars
merged: list[Note | Drumroll | Balloon] = []
i = 0
j = 0
while i < len(list1) and j < len(list2):
if list1[i] <= list2[j]:
merged.append(list1[i])
i += 1
else:
merged.append(list2[j])
j += 1
merged.extend(list1[i:])
merged.extend(list2[j:])
for item in merged:
n.update(item.get_hash().encode('utf-8'))
return n.hexdigest()

2
libs/screen.py
View File

@@ -3,6 +3,7 @@ from typing import Any
from libs.audio import audio
from libs.texture import tex
from libs.utils import input_state
logger = logging.getLogger(__name__)
@@ -34,6 +35,7 @@ class Screen:
return next_screen
def update(self) -> Any:
input_state.update()
ret_val = self._do_screen_start()
if ret_val:
return ret_val

48
libs/song_hash.py
View File

@@ -5,12 +5,10 @@ import logging
import sqlite3
import time
from pathlib import Path
import zipfile
from libs.config import get_config
from libs.global_data import Crown
from libs.parsers.osz import OsuParser
from libs.parsers.tja import NoteList, TJAParser, test_encodings
from libs.tja import NoteList, TJAParser, test_encodings
from libs.utils import global_data
logger = logging.getLogger(__name__)
@@ -107,24 +105,12 @@ def build_song_hashes(output_dir=Path("cache")):
for root_dir in tja_paths:
root_path = Path(root_dir)
found_tja_files = root_path.rglob("*.tja", recurse_symlinks=True)
found_osz_files = root_path.rglob("*.osz", recurse_symlinks=True)
found_osu_files = root_path.rglob("*.osu", recurse_symlinks=True)
all_tja_files.extend(found_tja_files)
all_tja_files.extend(found_osz_files)
all_tja_files.extend(found_osu_files)
global_data.total_songs = len(all_tja_files)
files_to_process = []
for tja_path in all_tja_files:
if tja_path.suffix == '.osz':
with zipfile.ZipFile(tja_path, 'r') as zip_file:
zip_file.extractall(tja_path.with_suffix(''))
zip_path = Path(tja_path.with_suffix(''))
tja_path.unlink()
for file in zip_path.glob('*.osu'):
files_to_process.append(file)
continue
tja_path_str = str(tja_path)
current_modified = tja_path.stat().st_mtime
if current_modified <= saved_timestamp:
@@ -147,24 +133,16 @@ def build_song_hashes(output_dir=Path("cache")):
global_data.total_songs = total_songs
for tja_path in files_to_process:
if tja_path.suffix == '.osu':
parser = OsuParser(tja_path)
path_str = str(tja_path)
current_modified = tja_path.stat().st_mtime
diff_hashes = dict()
all_notes = parser.notes_to_position(0)[0]
diff_hashes[0] = parser.hash_note_data(all_notes)
else:
try:
path_str = str(tja_path)
tja_path_str = str(tja_path)
current_modified = tja_path.stat().st_mtime
parser = TJAParser(tja_path)
tja = TJAParser(tja_path)
all_notes = NoteList()
diff_hashes = dict()
for diff in parser.metadata.course_data:
diff_notes, branch_m, branch_e, branch_n = TJAParser.notes_to_position(TJAParser(parser.file_path), diff)
diff_hashes[diff] = parser.hash_note_data(diff_notes)
for diff in tja.metadata.course_data:
diff_notes, branch_m, branch_e, branch_n = TJAParser.notes_to_position(TJAParser(tja.file_path), diff)
diff_hashes[diff] = tja.hash_note_data(diff_notes)
all_notes.play_notes.extend(diff_notes.play_notes)
if branch_m:
for branch in branch_m:
@@ -186,25 +164,25 @@ def build_song_hashes(output_dir=Path("cache")):
if all_notes == NoteList():
continue
hash_val = parser.hash_note_data(all_notes)
hash_val = tja.hash_note_data(all_notes)
if hash_val not in song_hashes:
song_hashes[hash_val] = []
song_hashes[hash_val].append({
"file_path": path_str,
"file_path": tja_path_str,
"last_modified": current_modified,
"title": parser.metadata.title,
"subtitle": parser.metadata.subtitle,
"title": tja.metadata.title,
"subtitle": tja.metadata.subtitle,
"diff_hashes": diff_hashes
})
# Update both indexes
path_to_hash[path_str] = hash_val
path_to_hash[tja_path_str] = hash_val
global_data.song_paths[tja_path] = hash_val
# Prepare database updates for each difficulty
en_name = parser.metadata.title.get('en', '') if isinstance(parser.metadata.title, dict) else str(parser.metadata.title)
jp_name = parser.metadata.title.get('ja', '') if isinstance(parser.metadata.title, dict) else ''
en_name = tja.metadata.title.get('en', '') if isinstance(tja.metadata.title, dict) else str(tja.metadata.title)
jp_name = tja.metadata.title.get('ja', '') if isinstance(tja.metadata.title, dict) else ''
score_ini_path = tja_path.with_suffix('.tja.score.ini')
if score_ini_path.exists():

1
libs/parsers/tja.py → libs/tja.py
View File

@@ -2,6 +2,7 @@ import hashlib
import logging
import math
import random
from collections import deque
from dataclasses import dataclass, field, fields
from enum import IntEnum
from functools import lru_cache

22
libs/utils.py
View File

@@ -1,10 +1,9 @@
import string
import ctypes
import hashlib
import sys
import logging
import string
import sys
import time
from libs.global_data import PlayerNum, global_data
from pathlib import Path
from typing import Optional
@@ -16,6 +15,7 @@ from raylib import (
SHADER_UNIFORM_VEC4,
)
from libs.global_data import PlayerNum, global_data
from libs.texture import TextureWrapper
logger = logging.getLogger(__name__)
@@ -57,11 +57,25 @@ def strip_comments(code: str) -> str:
index += 1
return result
class InputState:
def __init__(self):
self.pressed_keys_this_frame = set()
def update(self):
"""Call this once per frame to drain the key queue"""
self.pressed_keys_this_frame.clear()
key = rl.GetKeyPressed()
while key > 0:
self.pressed_keys_this_frame.add(key)
key = rl.GetKeyPressed()
input_state = InputState()
def is_input_key_pressed(keys: list[int], gamepad_buttons: list[int]):
if global_data.input_locked:
return False
for key in keys:
if rl.IsKeyPressed(key):
if key in input_state.pressed_keys_this_frame:
return True
if rl.IsGamepadAvailable(0):

17
libs/video.py
View File

@@ -14,12 +14,6 @@ class VideoPlayer:
def __init__(self, path: Path):
"""Initialize a video player instance"""
self.is_finished_list = [False, False]
self.is_static = False
if path.suffix == '.png' or path.suffix == '.jpg':
self.texture = ray.LoadTexture(str(path).encode('utf-8'))
self.is_static = True
return
self.container = av.open(str(path))
self.video_stream = self.container.streams.video[0]
@@ -150,8 +144,6 @@ class VideoPlayer:
def start(self, current_ms: float) -> None:
"""Start video playback at call time"""
if self.is_static:
return
self.start_ms = current_ms
self._init_frame_generator()
self._load_frame(0)
@@ -162,15 +154,11 @@ class VideoPlayer:
def set_volume(self, volume: float) -> None:
"""Set video volume, takes float value from 0.0 to 1.0"""
if self.is_static:
return
if self.audio is not None:
audio.set_music_volume(self.audio, volume)
def update(self):
"""Updates video playback, advancing frames and audio"""
if self.is_static:
return
self._audio_manager()
if self.frame_index >= len(self.frame_timestamps):
@@ -209,11 +197,6 @@ class VideoPlayer:
def stop(self):
"""Stops the video, audio, and clears its buffer"""
if self.is_static:
if self.texture is not None:
ray.UnloadTexture(self.texture)
self.texture = None
return
if self.container:
self.container.close()

22
scenes/ai_battle/game.py
View File

@@ -15,7 +15,7 @@ from libs.chara_2d import Chara2D
from libs.global_data import Difficulty, Modifiers, PlayerNum, global_data
from libs.global_objects import Nameplate
from libs.texture import tex
from libs.parsers.tja import TJAParser
from libs.tja import TJAParser
from libs.utils import get_current_ms, global_tex
from scenes.game import (
DrumType,
@@ -100,21 +100,21 @@ class AIBattleGameScreen(GameScreen):
def init_tja(self, song: Path):
"""Initialize the TJA file"""
self.parser = TJAParser(song, start_delay=self.start_delay)
self.tja = TJAParser(song, start_delay=self.start_delay)
self.movie = None
session_data = global_data.session_data[global_data.player_num]
session_data.song_title = self.parser.metadata.title.get(global_data.config['general']['language'].lower(), self.parser.metadata.title['en'])
if self.parser.metadata.wave.exists() and self.parser.metadata.wave.is_file() and self.song_music is None:
self.song_music = audio.load_music_stream(self.parser.metadata.wave, 'song')
session_data.song_title = self.tja.metadata.title.get(global_data.config['general']['language'].lower(), self.tja.metadata.title['en'])
if self.tja.metadata.wave.exists() and self.tja.metadata.wave.is_file() and self.song_music is None:
self.song_music = audio.load_music_stream(self.tja.metadata.wave, 'song')
tja_copy = copy.deepcopy(self.parser)
self.player_1 = PlayerNoChara(self.parser, global_data.player_num, session_data.selected_difficulty, False, global_data.modifiers[global_data.player_num])
self.player_1.gauge = AIGauge(self.player_1.player_num, self.player_1.difficulty, self.parser.metadata.course_data[self.player_1.difficulty].level, self.player_1.total_notes, self.player_1.is_2p)
tja_copy = copy.deepcopy(self.tja)
self.player_1 = PlayerNoChara(self.tja, global_data.player_num, session_data.selected_difficulty, False, global_data.modifiers[global_data.player_num])
self.player_1.gauge = AIGauge(self.player_1.player_num, self.player_1.difficulty, self.tja.metadata.course_data[self.player_1.difficulty].level, self.player_1.total_notes, self.player_1.is_2p)
ai_modifiers = copy.deepcopy(global_data.modifiers[global_data.player_num])
ai_modifiers.auto = True
self.player_2 = AIPlayer(tja_copy, PlayerNum.AI, session_data.selected_difficulty, True, ai_modifiers, AIDifficulty.LVL_2)
self.start_ms = (get_current_ms() - self.parser.metadata.offset*1000)
self.precise_start = time.time() - self.parser.metadata.offset
self.start_ms = (get_current_ms() - self.tja.metadata.offset*1000)
self.precise_start = time.time() - self.tja.metadata.offset
self.total_notes = len(self.player_1.don_notes) + len(self.player_1.kat_notes)
logger.info(f"TJA initialized for two-player song: {song}")
@@ -140,7 +140,7 @@ class AIBattleGameScreen(GameScreen):
if self.transition.is_finished:
self.start_song(self.current_ms)
else:
self.start_ms = current_time - self.parser.metadata.offset*1000
self.start_ms = current_time - self.tja.metadata.offset*1000
self.update_background(current_time)
self.update_audio(self.current_ms)

4
scenes/ai_battle/song_select.py
View File

@@ -98,7 +98,7 @@ class AISongSelectPlayer(SongSelectPlayer):
def on_song_selected(self, selected_song: SongFile):
"""Called when a song is selected"""
super().on_song_selected(selected_song)
self.subdiff_selector = SubdiffSelector(self.player_num, min(selected_song.parser.metadata.course_data))
self.subdiff_selector = SubdiffSelector(self.player_num, min(selected_song.tja.metadata.course_data))
def handle_input_selected(self, current_item):
"""Handle input for selecting difficulty. Returns 'cancel', 'confirm', or None"""
@@ -158,7 +158,7 @@ class AISongSelectPlayer(SongSelectPlayer):
if is_l_kat_pressed(self.player_num) or is_r_kat_pressed(self.player_num):
audio.play_sound('kat', 'sound')
selected_song = current_item
diffs = sorted(selected_song.parser.metadata.course_data)
diffs = sorted(selected_song.tja.metadata.course_data)
prev_diff = self.selected_difficulty
ret_val = None

18
scenes/dan/game_dan.py
View File

@@ -16,7 +16,7 @@ from libs.global_data import (
)
from libs.global_objects import AllNetIcon
from libs.texture import tex
from libs.parsers.tja import TJAParser
from libs.tja import TJAParser
from libs.transition import Transition
from libs.utils import OutlinedText, get_current_ms
from scenes.game import (
@@ -90,7 +90,7 @@ class DanGameScreen(GameScreen):
self.player_1.is_dan = True
self.player_1.gauge = DanGauge(global_data.player_num, self.total_notes)
self.song_info = SongInfo(song.metadata.title.get(global_data.config["general"]["language"], "en"), genre_index)
self.bpm = self.parser.metadata.bpm
self.bpm = self.tja.metadata.bpm
logger.info(f"TJA initialized for song: {song.file_path}")
@@ -103,19 +103,19 @@ class DanGameScreen(GameScreen):
song, genre_index, difficulty, level = songs[self.song_index]
session_data.selected_difficulty = difficulty
self.player_1.difficulty = difficulty
self.parser = TJAParser(song.file_path, start_delay=self.start_delay)
self.tja = TJAParser(song.file_path, start_delay=self.start_delay)
if self.song_music is not None:
audio.unload_music_stream(self.song_music)
self.song_music = None
self.song_started = False
if self.parser.metadata.wave.exists() and self.parser.metadata.wave.is_file() and self.song_music is None:
self.song_music = audio.load_music_stream(self.parser.metadata.wave, 'song')
self.player_1.parser = self.parser
if self.tja.metadata.wave.exists() and self.tja.metadata.wave.is_file() and self.song_music is None:
self.song_music = audio.load_music_stream(self.tja.metadata.wave, 'song')
self.player_1.tja = self.tja
self.player_1.reset_chart()
self.dan_transition.start()
self.song_info = SongInfo(self.parser.metadata.title.get(global_data.config["general"]["language"], "en"), genre_index)
self.start_ms = (get_current_ms() - self.parser.metadata.offset*1000)
self.song_info = SongInfo(self.tja.metadata.title.get(global_data.config["general"]["language"], "en"), genre_index)
self.start_ms = (get_current_ms() - self.tja.metadata.offset*1000)
def _calculate_dan_info(self):
"""Calculate all dan info data for drawing"""
@@ -205,7 +205,7 @@ class DanGameScreen(GameScreen):
if self.transition.is_finished and self.dan_transition.is_finished:
self.start_song(self.current_ms)
else:
self.start_ms = current_time - self.parser.metadata.offset*1000
self.start_ms = current_time - self.tja.metadata.offset*1000
self.update_background(current_time)
if self.song_music is not None:

64
scenes/game.py
View File

@@ -23,10 +23,9 @@ from libs.global_data import (
ScoreMethod,
)
from libs.global_objects import AllNetIcon, Nameplate
from libs.parsers.osz import OsuParser
from libs.screen import Screen
from libs.texture import tex
from libs.parsers.tja import (
from libs.tja import (
Balloon,
Drumroll,
Note,
@@ -99,9 +98,9 @@ class GameScreen(Screen):
self.load_hitsounds()
self.song_info = SongInfo(session_data.song_title, session_data.genre_index)
self.result_transition = ResultTransition(global_data.player_num)
subtitle = self.parser.metadata.subtitle.get(global_data.config['general']['language'].lower(), '')
self.bpm = self.parser.metadata.bpm
scene_preset = self.parser.metadata.scene_preset
subtitle = self.tja.metadata.subtitle.get(global_data.config['general']['language'].lower(), '')
self.bpm = self.tja.metadata.bpm
scene_preset = self.tja.metadata.scene_preset
if self.movie is None:
self.background = Background(global_data.player_num, self.bpm, scene_preset=scene_preset)
logger.info("Background initialized")
@@ -145,22 +144,18 @@ class GameScreen(Screen):
def init_tja(self, song: Path):
"""Initialize the TJA file"""
if song.suffix == '.osu':
self.start_delay = 0
self.parser = OsuParser(song)
else:
self.parser = TJAParser(song, start_delay=self.start_delay)
if self.parser.metadata.bgmovie != Path() and self.parser.metadata.bgmovie.exists():
self.movie = VideoPlayer(self.parser.metadata.bgmovie)
self.tja = TJAParser(song, start_delay=self.start_delay)
if self.tja.metadata.bgmovie != Path() and self.tja.metadata.bgmovie.exists():
self.movie = VideoPlayer(self.tja.metadata.bgmovie)
else:
self.movie = None
global_data.session_data[global_data.player_num].song_title = self.parser.metadata.title.get(global_data.config['general']['language'].lower(), self.parser.metadata.title['en'])
if self.parser.metadata.wave.exists() and self.parser.metadata.wave.is_file() and self.song_music is None:
self.song_music = audio.load_music_stream(self.parser.metadata.wave, 'song')
global_data.session_data[global_data.player_num].song_title = self.tja.metadata.title.get(global_data.config['general']['language'].lower(), self.tja.metadata.title['en'])
if self.tja.metadata.wave.exists() and self.tja.metadata.wave.is_file() and self.song_music is None:
self.song_music = audio.load_music_stream(self.tja.metadata.wave, 'song')
self.player_1 = Player(self.parser, global_data.player_num, global_data.session_data[global_data.player_num].selected_difficulty, False, global_data.modifiers[global_data.player_num])
self.start_ms = get_current_ms() - self.parser.metadata.offset*1000
self.precise_start = time.time() - self.parser.metadata.offset
self.player_1 = Player(self.tja, global_data.player_num, global_data.session_data[global_data.player_num].selected_difficulty, False, global_data.modifiers[global_data.player_num])
self.start_ms = get_current_ms() - self.tja.metadata.offset*1000
self.precise_start = time.time() - self.tja.metadata.offset
def write_score(self):
"""Write the score to the database"""
@@ -176,7 +171,7 @@ class GameScreen(Screen):
existing_score = result[0] if result is not None else None
existing_crown = result[1] if result is not None and len(result) > 1 and result[1] is not None else 0
crown = Crown.NONE
if session_data.result_data.bad == 0 and session_data.result_data.ok == 0:
if session_data.result_data.bad and session_data.result_data.ok == 0:
crown = Crown.DFC
elif session_data.result_data.bad == 0:
crown = Crown.FC
@@ -188,21 +183,21 @@ class GameScreen(Screen):
INSERT OR REPLACE INTO Scores (hash, en_name, jp_name, diff, score, good, ok, bad, drumroll, combo, clear)
VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);
'''
data = (hash, self.parser.metadata.title['en'],
self.parser.metadata.title.get('ja', ''), self.player_1.difficulty,
data = (hash, self.tja.metadata.title['en'],
self.tja.metadata.title.get('ja', ''), self.player_1.difficulty,
session_data.result_data.score, session_data.result_data.good,
session_data.result_data.ok, session_data.result_data.bad,
session_data.result_data.total_drumroll, session_data.result_data.max_combo, crown)
cursor.execute(insert_query, data)
session_data.result_data.prev_score = existing_score if existing_score is not None else 0
logger.info(f"Wrote score {session_data.result_data.score} for {self.parser.metadata.title['en']}")
logger.info(f"Wrote score {session_data.result_data.score} for {self.tja.metadata.title['en']}")
con.commit()
if result is None or (existing_crown is not None and crown > existing_crown):
cursor.execute("UPDATE Scores SET clear = ? WHERE hash = ?", (crown, hash))
con.commit()
def start_song(self, ms_from_start):
if (ms_from_start >= self.parser.metadata.offset*1000 + self.start_delay - global_data.config["general"]["audio_offset"]) and not self.song_started:
if (ms_from_start >= self.tja.metadata.offset*1000 + self.start_delay - global_data.config["general"]["audio_offset"]) and not self.song_started:
if self.song_music is not None:
audio.play_music_stream(self.song_music, 'music')
logger.info(f"Song started at {ms_from_start}")
@@ -280,7 +275,7 @@ class GameScreen(Screen):
if self.transition.is_finished:
self.start_song(self.current_ms)
else:
self.start_ms = current_time - self.parser.metadata.offset*1000
self.start_ms = current_time - self.tja.metadata.offset*1000
self.update_background(current_time)
self.update_audio(self.current_ms)
@@ -335,7 +330,7 @@ class Player:
TIMING_OK_EASY = 108.441665649414
TIMING_BAD_EASY = 125.125
def __init__(self, parser: TJAParser | OsuParser, player_num: PlayerNum, difficulty: int, is_2p: bool, modifiers: Modifiers):
def __init__(self, tja: TJAParser, player_num: PlayerNum, difficulty: int, is_2p: bool, modifiers: Modifiers):
self.is_2p = is_2p
self.is_dan = False
self.player_num = player_num
@@ -343,7 +338,7 @@ class Player:
self.visual_offset = global_data.config["general"]["visual_offset"]
self.score_method = global_data.config["general"]["score_method"]
self.modifiers = modifiers
self.parser = parser
self.tja = tja
self.reset_chart()
@@ -374,10 +369,7 @@ class Player:
self.delay_start: Optional[float] = None
self.delay_end: Optional[float] = None
self.combo_announce = ComboAnnounce(self.combo, 0, player_num, self.is_2p)
if not parser.metadata.course_data:
self.branch_indicator = None
else:
self.branch_indicator = BranchIndicator(self.is_2p) if parser and parser.metadata.course_data[self.difficulty].is_branching else None
self.branch_indicator = BranchIndicator(self.is_2p) if tja and tja.metadata.course_data[self.difficulty].is_branching else None
self.ending_anim: Optional[FailAnimation | ClearAnimation | FCAnimation] = None
self.is_gogo_time = False
plate_info = global_data.config[f'nameplate_{self.is_2p+1}p']
@@ -389,10 +381,7 @@ class Player:
self.judge_counter = None
self.input_log: dict[float, str] = dict()
if not parser.metadata.course_data:
stars = 10
else:
stars = parser.metadata.course_data[self.difficulty].level
stars = tja.metadata.course_data[self.difficulty].level
self.gauge = Gauge(self.player_num, self.difficulty, stars, self.total_notes, self.is_2p)
self.gauge_hit_effect: list[GaugeHitEffect] = []
@@ -425,8 +414,9 @@ class Player:
unload_offset = travel_distance / sudden_pixels_per_ms
note.unload_ms = note.hit_ms + unload_offset
def reset_chart(self):
notes, self.branch_m, self.branch_e, self.branch_n = self.parser.notes_to_position(self.difficulty)
notes, self.branch_m, self.branch_e, self.branch_n = self.tja.notes_to_position(self.difficulty)
self.play_notes, self.draw_note_list, self.draw_bar_list = deque(apply_modifiers(notes, self.modifiers)[0]), deque(apply_modifiers(notes, self.modifiers)[1]), deque(apply_modifiers(notes, self.modifiers)[2])
self.don_notes = deque([note for note in self.play_notes if note.type in {NoteType.DON, NoteType.DON_L}])
@@ -444,12 +434,12 @@ class Player:
if self.score_method == ScoreMethod.SHINUCHI:
self.base_score = calculate_base_score(total_notes)
elif self.score_method == ScoreMethod.GEN3:
self.score_diff = self.parser.metadata.course_data[self.difficulty].scorediff
self.score_diff = self.tja.metadata.course_data[self.difficulty].scorediff
if self.score_diff <= 0:
logger.warning("Error: No scorediff specified or scorediff less than 0 | Using shinuchi scoring method instead")
self.score_diff = 0
score_init_list = self.parser.metadata.course_data[self.difficulty].scoreinit
score_init_list = self.tja.metadata.course_data[self.difficulty].scoreinit
if len(score_init_list) <= 0:
logger.warning("Error: No scoreinit specified or scoreinit less than 0 | Using shinuchi scoring method instead")
self.score_init = calculate_base_score(total_notes)

22
scenes/practice/game.py
View File

@@ -12,7 +12,7 @@ from libs.audio import audio
from libs.background import Background
from libs.global_data import Modifiers, PlayerNum, global_data
from libs.texture import tex
from libs.parsers.tja import (
from libs.tja import (
Balloon,
Drumroll,
NoteType,
@@ -46,16 +46,16 @@ class PracticeGameScreen(GameScreen):
def init_tja(self, song: Path):
"""Initialize the TJA file"""
self.parser = TJAParser(song, start_delay=self.start_delay)
self.tja = TJAParser(song, start_delay=self.start_delay)
self.scrobbling_tja = TJAParser(song, start_delay=self.start_delay)
global_data.session_data[global_data.player_num].song_title = self.parser.metadata.title.get(global_data.config['general']['language'].lower(), self.parser.metadata.title['en'])
if self.parser.metadata.wave.exists() and self.parser.metadata.wave.is_file() and self.song_music is None:
self.song_music = audio.load_music_stream(self.parser.metadata.wave, 'song')
self.player_1 = PracticePlayer(self.parser, global_data.player_num, global_data.session_data[global_data.player_num].selected_difficulty, False, global_data.modifiers[global_data.player_num])
notes, branch_m, branch_e, branch_n = self.parser.notes_to_position(self.player_1.difficulty)
global_data.session_data[global_data.player_num].song_title = self.tja.metadata.title.get(global_data.config['general']['language'].lower(), self.tja.metadata.title['en'])
if self.tja.metadata.wave.exists() and self.tja.metadata.wave.is_file() and self.song_music is None:
self.song_music = audio.load_music_stream(self.tja.metadata.wave, 'song')
self.player_1 = PracticePlayer(self.tja, global_data.player_num, global_data.session_data[global_data.player_num].selected_difficulty, False, global_data.modifiers[global_data.player_num])
notes, branch_m, branch_e, branch_n = self.tja.notes_to_position(self.player_1.difficulty)
self.scrobble_timeline = notes.timeline
_, self.scrobble_note_list, self.bars = apply_modifiers(notes, self.player_1.modifiers)
self.start_ms = (get_current_ms() - self.parser.metadata.offset*1000)
self.start_ms = (get_current_ms() - self.tja.metadata.offset*1000)
self.scrobble_index = 0
self.scrobble_time = self.bars[self.scrobble_index].hit_ms
self.scrobble_move = Animation.create_move(200, total_distance=0)
@@ -98,7 +98,7 @@ class PracticeGameScreen(GameScreen):
start_time = self.bars[previous_bar_index].hit_ms - first_bar_time + self.start_delay
tja_copy = copy.deepcopy(self.scrobbling_tja)
self.player_1.parser = tja_copy
self.player_1.tja = tja_copy
self.player_1.reset_chart()
self.player_1.don_notes = deque([note for note in self.player_1.don_notes if note.hit_ms > resume_time])
@@ -110,7 +110,7 @@ class PracticeGameScreen(GameScreen):
self.pause_time = start_time
audio.play_music_stream(self.song_music, 'music')
audio.seek_music_stream(self.song_music, (self.pause_time - self.start_delay)/1000 - self.parser.metadata.offset)
audio.seek_music_stream(self.song_music, (self.pause_time - self.start_delay)/1000 - self.tja.metadata.offset)
self.song_started = True
self.start_ms = get_current_ms() - self.pause_time
@@ -156,7 +156,7 @@ class PracticeGameScreen(GameScreen):
if self.transition.is_finished:
self.start_song(self.current_ms)
else:
self.start_ms = current_time - self.parser.metadata.offset*1000
self.start_ms = current_time - self.tja.metadata.offset*1000
self.update_background(current_time)
if self.song_music is not None:

707
scenes/settings.py
View File

@@ -1,17 +1,12 @@
import json
import logging
import pyray as ray
from libs.animation import Animation
from libs.audio import audio
from libs.config import get_key_string, save_config
from libs.global_objects import AllNetIcon, CoinOverlay, Indicator
from libs.config import save_config
from libs.screen import Screen
from libs.texture import tex
from libs.utils import (
OutlinedText,
get_current_ms,
global_data,
is_l_don_pressed,
is_l_kat_pressed,
@@ -21,482 +16,262 @@ from libs.utils import (
logger = logging.getLogger(__name__)
class BaseOptionBox:
def __init__(self, name: str, description: str, path: str, values: dict):
self.name = OutlinedText(name, 30, ray.WHITE)
self.setting_header, self.setting_name = path.split('/')
self.description = description
self.is_highlighted = False
self.value = global_data.config[self.setting_header][self.setting_name]
def update(self, current_time):
pass
def move_left(self):
pass
def move_right(self):
pass
def confirm(self):
global_data.config[self.setting_header][self.setting_name] = self.value
def __repr__(self):
return str(self.__dict__)
def draw(self):
tex.draw_texture('background', 'overlay', scale=0.70)
if self.is_highlighted:
tex.draw_texture('background', 'title_highlight')
else:
tex.draw_texture('background', 'title')
text_x = tex.textures['background']['title'].x[0] + (tex.textures['background']['title'].width//2) - (self.name.texture.width//2)
text_y = tex.textures['background']['title'].y[0] + self.name.texture.height//4
self.name.draw(outline_color=ray.BLACK, x=text_x, y=text_y)
ray.draw_text_ex(global_data.font, self.description, (450 * tex.screen_scale, 270 * tex.screen_scale), 25 * tex.screen_scale, 1, ray.BLACK)
class BoolOptionBox(BaseOptionBox):
def __init__(self, name: str, description: str, path: str, values: dict):
super().__init__(name, description, path, values)
language = global_data.config["general"]["language"]
self.on_value = OutlinedText(values["true"].get(language, values["true"]["en"]), int(30 * tex.screen_scale), ray.WHITE)
self.off_value = OutlinedText(values["false"].get(language, values["false"]["en"]), int(30 * tex.screen_scale), ray.WHITE)
def move_left(self):
self.value = False
def move_right(self):
self.value = True
def draw(self):
super().draw()
if not self.value:
tex.draw_texture('option', 'button_on', index=0)
else:
tex.draw_texture('option', 'button_off', index=0)
text_x = tex.textures["option"]["button_on"].x[0] + (tex.textures["option"]["button_on"].width//2) - (self.off_value.texture.width//2)
text_y = tex.textures["option"]["button_on"].y[0] + (tex.textures["option"]["button_on"].height//2) - (self.off_value.texture.height//2)
self.off_value.draw(outline_color=ray.BLACK, x=text_x, y=text_y)
if self.value:
tex.draw_texture('option', 'button_on', index=1)
else:
tex.draw_texture('option', 'button_off', index=1)
text_x = tex.textures["option"]["button_on"].x[1] + (tex.textures["option"]["button_on"].width//2) - (self.on_value.texture.width//2)
text_y = tex.textures["option"]["button_on"].y[1] + (tex.textures["option"]["button_on"].height//2) - (self.on_value.texture.height//2)
self.on_value.draw(outline_color=ray.BLACK, x=text_x, y=text_y)
class IntOptionBox(BaseOptionBox):
def __init__(self, name: str, description: str, path: str, values: dict):
super().__init__(name, description, path, values)
self.value_text = OutlinedText(str(self.value), int(30 * tex.screen_scale), ray.WHITE)
self.flicker_fade = Animation.create_fade(400, initial_opacity=0.0, final_opacity=1.0, reverse_delay=0, loop=True)
self.flicker_fade.start()
language = global_data.config["general"]["language"]
self.value_list = []
if values != dict():
self.value_list = list(values.keys())
self.value_index = 0
self.values = values
self.value_text = OutlinedText(self.values[str(self.value)].get(language, self.values[str(self.value)]["en"]), int(30 * tex.screen_scale), ray.WHITE)
def update(self, current_time):
self.flicker_fade.update(current_time)
def move_left(self):
if self.value_list:
self.value_index = max(self.value_index - 1, 0)
self.value = int(self.value_list[self.value_index])
self.value_text = OutlinedText(self.values[str(self.value)].get(global_data.config["general"]["language"], self.values[str(self.value)]["en"]), int(30 * tex.screen_scale), ray.WHITE)
else:
self.value -= 1
self.value_text = OutlinedText(str(self.value), int(30 * tex.screen_scale), ray.WHITE)
def move_right(self):
if self.value_list:
self.value_index = min(self.value_index + 1, len(self.value_list) - 1)
self.value = int(self.value_list[self.value_index])
self.value_text = OutlinedText(self.values[str(self.value)].get(global_data.config["general"]["language"], self.values[str(self.value)]["en"]), int(30 * tex.screen_scale), ray.WHITE)
else:
self.value += 1
self.value_text = OutlinedText(str(self.value), int(30 * tex.screen_scale), ray.WHITE)
def draw(self):
super().draw()
tex.draw_texture('option', 'button_off', index=2)
if self.is_highlighted:
tex.draw_texture('option', 'button_on', index=2, fade=self.flicker_fade.attribute)
text_x = tex.textures["option"]["button_on"].x[2] + (tex.textures["option"]["button_on"].width//2) - (self.value_text.texture.width//2)
text_y = tex.textures["option"]["button_on"].y[2] + (tex.textures["option"]["button_on"].height//2) - (self.value_text.texture.height//2)
self.value_text.draw(outline_color=ray.BLACK, x=text_x, y=text_y)
class StrOptionBox(BaseOptionBox):
def __init__(self, name: str, description: str, path: str, values: dict):
super().__init__(name, description, path, values)
self.flicker_fade = Animation.create_fade(400, initial_opacity=0.0, final_opacity=1.0, reverse_delay=0, loop=True)
self.flicker_fade.start()
self.value_list = []
if values != dict():
self.value_list = list(values.keys())
self.value_index = 0
self.values = values
language = global_data.config["general"]["language"]
self.value_text = OutlinedText(self.values[self.value].get(language, self.values[self.value]["en"]), int(30 * tex.screen_scale), ray.WHITE)
else:
self.string = self.value
self.value_text = OutlinedText(self.value, int(30 * tex.screen_scale), ray.WHITE)
def update(self, current_time):
self.flicker_fade.update(current_time)
if self.is_highlighted and self.value_list == []:
if ray.is_key_pressed(ray.KeyboardKey.KEY_BACKSPACE):
self.string = self.string[:-1]
self.value_text = OutlinedText(self.string, int(30 * tex.screen_scale), ray.WHITE)
elif ray.is_key_pressed(ray.KeyboardKey.KEY_ENTER):
self.value = self.string
self.is_highlighted = False
key = ray.get_char_pressed()
if key > 0:
self.string += chr(key)
self.value_text = OutlinedText(self.string, int(30 * tex.screen_scale), ray.WHITE)
def move_left(self):
if self.value_list:
self.value_index = max(self.value_index - 1, 0)
self.value = self.value_list[self.value_index]
self.value_text = OutlinedText(self.values[self.value].get(global_data.config["general"]["language"], self.values[self.value]["en"]), int(30 * tex.screen_scale), ray.WHITE)
def move_right(self):
if self.value_list:
self.value_index = min(self.value_index + 1, len(self.value_list) - 1)
self.value = self.value_list[self.value_index]
self.value_text = OutlinedText(self.values[self.value].get(global_data.config["general"]["language"], self.values[self.value]["en"]), int(30 * tex.screen_scale), ray.WHITE)
def draw(self):
super().draw()
tex.draw_texture('option', 'button_off', index=2)
if self.is_highlighted:
tex.draw_texture('option', 'button_on', index=2, fade=self.flicker_fade.attribute)
text_x = tex.textures["option"]["button_on"].x[2] + (tex.textures["option"]["button_on"].width//2) - (self.value_text.texture.width//2)
text_y = tex.textures["option"]["button_on"].y[2] + (tex.textures["option"]["button_on"].height//2) - (self.value_text.texture.height//2)
self.value_text.draw(outline_color=ray.BLACK, x=text_x, y=text_y)
class KeybindOptionBox(BaseOptionBox):
def __init__(self, name: str, description: str, path: str, values: dict):
super().__init__(name, description, path, values)
if isinstance(self.value, list):
text = ', '.join([get_key_string(key) for key in self.value])
else:
text = get_key_string(self.value)
self.value_text = OutlinedText(text, int(30 * tex.screen_scale), ray.WHITE)
self.flicker_fade = Animation.create_fade(400, initial_opacity=0.0, final_opacity=1.0, reverse_delay=0, loop=True)
self.flicker_fade.start()
def update(self, current_time):
self.flicker_fade.update(current_time)
if self.is_highlighted:
key = ray.get_key_pressed()
if key > 0:
self.value = key
audio.play_sound('don', 'sound')
self.value_text = OutlinedText(get_key_string(self.value), int(30 * tex.screen_scale), ray.WHITE)
self.is_highlighted = False
def draw(self):
super().draw()
tex.draw_texture('option', 'button_off', index=2)
if self.is_highlighted:
tex.draw_texture('option', 'button_on', index=2, fade=self.flicker_fade.attribute)
text_x = tex.textures["option"]["button_on"].x[2] + (tex.textures["option"]["button_on"].width//2) - (self.value_text.texture.width//2)
text_y = tex.textures["option"]["button_on"].y[2] + (tex.textures["option"]["button_on"].height//2) - (self.value_text.texture.height//2)
self.value_text.draw(outline_color=ray.BLACK, x=text_x, y=text_y)
class KeyBindControllerOptionBox(BaseOptionBox):
def __init__(self, name: str, description: str, path: str, values: dict):
super().__init__(name, description, path, values)
if isinstance(self.value, list):
text = ', '.join([str(key) for key in self.value])
else:
text = str(self.value)
self.value_text = OutlinedText(text, int(30 * tex.screen_scale), ray.WHITE)
self.flicker_fade = Animation.create_fade(400, initial_opacity=0.0, final_opacity=1.0, reverse_delay=0, loop=True)
self.flicker_fade.start()
def update(self, current_time):
self.flicker_fade.update(current_time)
if self.is_highlighted:
key = ray.get_gamepad_button_pressed()
if key > 0:
self.value = key
audio.play_sound('don', 'sound')
self.value_text = OutlinedText(str(self.value), int(30 * tex.screen_scale), ray.WHITE)
self.is_highlighted = False
def draw(self):
super().draw()
tex.draw_texture('option', 'button_off', index=2)
if self.is_highlighted:
tex.draw_texture('option', 'button_on', index=2, fade=self.flicker_fade.attribute)
text_x = tex.textures["option"]["button_on"].x[2] + (tex.textures["option"]["button_on"].width//2) - (self.value_text.texture.width//2)
text_y = tex.textures["option"]["button_on"].y[2] + (tex.textures["option"]["button_on"].height//2) - (self.value_text.texture.height//2)
self.value_text.draw(outline_color=ray.BLACK, x=text_x, y=text_y)
class FloatOptionBox(BaseOptionBox):
def __init__(self, name: str, description: str, path: str, values: dict):
super().__init__(name, description, path, values)
self.value_text = OutlinedText(str(int(self.value*100)) + "%", int(30 * tex.screen_scale), ray.WHITE)
self.flicker_fade = Animation.create_fade(400, initial_opacity=0.0, final_opacity=1.0, reverse_delay=0, loop=True)
self.flicker_fade.start()
def update(self, current_time):
self.flicker_fade.update(current_time)
def move_left(self):
self.value = ((self.value*100) - 1) / 100
self.value_text = OutlinedText(str(int(self.value*100))+"%", int(30 * tex.screen_scale), ray.WHITE)
def move_right(self):
self.value = ((self.value*100) + 1) / 100
self.value_text = OutlinedText(str(int(self.value*100))+"%", int(30 * tex.screen_scale), ray.WHITE)
def draw(self):
super().draw()
tex.draw_texture('option', 'button_off', index=2)
if self.is_highlighted:
tex.draw_texture('option', 'button_on', index=2, fade=self.flicker_fade.attribute)
text_x = tex.textures["option"]["button_on"].x[2] + (tex.textures["option"]["button_on"].width//2) - (self.value_text.texture.width//2)
text_y = tex.textures["option"]["button_on"].y[2] + (tex.textures["option"]["button_on"].height//2) - (self.value_text.texture.height//2)
self.value_text.draw(outline_color=ray.BLACK, x=text_x, y=text_y)
class Box:
"""Box class for the entry screen"""
OPTION_BOX_MAP = {
"int": IntOptionBox,
"bool": BoolOptionBox,
"string": StrOptionBox,
"keybind": KeybindOptionBox,
"keybind_controller": KeyBindControllerOptionBox,
"float": FloatOptionBox
}
def __init__(self, name: str, text: str, box_options: dict):
self.name = name
self.text = OutlinedText(text, tex.skin_config["entry_box_text"].font_size - int(5*tex.screen_scale), ray.WHITE, outline_thickness=5)
self.x = 10 * tex.screen_scale
self.y = -50 * tex.screen_scale
self.move = tex.get_animation(0)
self.blue_arrow_fade = tex.get_animation(1)
self.blue_arrow_move = tex.get_animation(2)
self.is_selected = False
self.in_box = False
self.outline_color = ray.Color(109, 68, 24, 255)
self.direction = 1
self.target_position = float('inf')
self.start_position = self.y
self.option_index = 0
language = global_data.config["general"]["language"]
self.options = [Box.OPTION_BOX_MAP[
box_options[option]["type"]](box_options[option]["name"].get(language, box_options[option]["name"]["en"]),
box_options[option]["description"].get(language, box_options[option]["description"]["en"]), box_options[option]["path"],
box_options[option]["values"]) for option in box_options]
def __repr__(self):
return str(self.__dict__)
def move_left(self):
"""Move the box left"""
if self.y != self.target_position and self.target_position != float('inf'):
return False
self.move.start()
self.direction = 1
self.start_position = self.y
self.target_position = self.y + (100 * tex.screen_scale * self.direction)
if self.target_position >= 650:
self.target_position = -50 + (self.target_position - 650)
return True
def move_right(self):
"""Move the box right"""
if self.y != self.target_position and self.target_position != float('inf'):
return False
self.move.start()
self.start_position = self.y
self.direction = -1
self.target_position = self.y + (100 * tex.screen_scale * self.direction)
if self.target_position < -50:
self.target_position = 650 + (self.target_position + 50)
return True
def move_option_left(self):
if self.options[self.option_index].is_highlighted:
self.options[self.option_index].move_left()
return True
else:
if self.option_index == 0:
self.in_box = False
return False
self.option_index -= 1
return True
def move_option_right(self):
if self.options[self.option_index].is_highlighted:
self.options[self.option_index].move_right()
else:
self.option_index = min(self.option_index + 1, len(self.options) - 1)
def select_option(self):
self.options[self.option_index].is_highlighted = not self.options[self.option_index].is_highlighted
self.options[self.option_index].confirm()
def select(self):
self.in_box = True
def update(self, current_time_ms: float, is_selected: bool):
self.move.update(current_time_ms)
self.blue_arrow_fade.update(current_time_ms)
self.blue_arrow_move.update(current_time_ms)
self.is_selected = is_selected
if self.move.is_finished:
self.y = self.target_position
else:
self.y = self.start_position + (self.move.attribute * self.direction)
for option in self.options:
option.update(current_time_ms)
def _draw_highlighted(self):
tex.draw_texture('box', 'box_highlight', x=self.x, y=self.y)
def _draw_text(self):
text_x = self.x + (tex.textures['box']['box'].width//2) - (self.text.texture.width//2)
text_y = self.y + (tex.textures['box']['box'].height//2) - (self.text.texture.height//2)
if self.is_selected:
self.text.draw(outline_color=ray.BLACK, x=text_x, y=text_y)
else:
if self.name == 'exit':
self.text.draw(outline_color=ray.RED, x=text_x, y=text_y)
else:
self.text.draw(outline_color=self.outline_color, x=text_x, y=text_y)
def draw(self):
tex.draw_texture('box', 'box', x=self.x, y=self.y)
if self.is_selected:
self._draw_highlighted()
if self.in_box:
self.options[self.option_index].draw()
if not self.options[self.option_index].is_highlighted:
tex.draw_texture('background', 'blue_arrow', index=0, x=-self.blue_arrow_move.attribute, fade=self.blue_arrow_fade.attribute)
if self.option_index != len(self.options) - 1:
tex.draw_texture('background', 'blue_arrow', index=1, x=self.blue_arrow_move.attribute, fade=self.blue_arrow_fade.attribute, mirror='horizontal')
self._draw_text()
class BoxManager:
"""BoxManager class for the entry screen"""
def __init__(self, settings_template: dict):
language = global_data.config["general"]["language"]
self.boxes = [Box(config_name, settings_template[config_name]["name"].get(language, settings_template[config_name]["name"]["en"]), settings_template[config_name]["options"]) for config_name in settings_template]
self.num_boxes = len(self.boxes)
self.selected_box_index = 3
self.box_selected = False
for i, box in enumerate(self.boxes):
box.y += 100*i
box.start_position += 100*i
def move_left(self):
"""Move the cursor to the left"""
if self.box_selected:
box = self.boxes[self.selected_box_index]
self.box_selected = box.move_option_left()
else:
moved = True
for box in self.boxes:
if not box.move_left():
moved = False
if moved:
self.selected_box_index = (self.selected_box_index - 1) % self.num_boxes
def move_right(self):
"""Move the cursor to the right"""
if self.box_selected:
box = self.boxes[self.selected_box_index]
box.move_option_right()
else:
moved = True
for box in self.boxes:
if not box.move_right():
moved = False
if moved:
self.selected_box_index = (self.selected_box_index + 1) % self.num_boxes
def select_box(self):
if self.boxes[self.selected_box_index].name == "exit":
return "exit"
if self.box_selected:
box = self.boxes[self.selected_box_index]
box.select_option()
else:
self.box_selected = True
self.boxes[self.selected_box_index].in_box = True
def update(self, current_time_ms: float):
for i, box in enumerate(self.boxes):
is_selected = i == self.selected_box_index and not self.box_selected
box.update(current_time_ms, is_selected)
def draw(self):
for box in self.boxes:
box.draw()
class SettingsScreen(Screen):
def on_screen_start(self):
super().on_screen_start()
self.indicator = Indicator(Indicator.State.SELECT)
self.template = json.loads((tex.graphics_path / "settings_template.json").read_text(encoding='utf-8'))
self.box_manager = BoxManager(self.template)
self.coin_overlay = CoinOverlay()
self.allnet_indicator = AllNetIcon()
audio.play_sound('bgm', 'music')
self.config = global_data.config
self.headers = list(self.config.keys())
self.headers.append('Exit')
self.header_index = 0
self.setting_index = 0
self.in_setting_edit = False
self.editing_key = False
self.editing_gamepad = False
def on_screen_end(self, next_screen: str):
save_config(global_data.config)
save_config(self.config)
global_data.config = self.config
audio.close_audio_device()
audio.device_type = global_data.config["audio"]["device_type"]
audio.target_sample_rate = global_data.config["audio"]["sample_rate"]
sample_rate = global_data.config["audio"]["sample_rate"]
if sample_rate < 0:
sample_rate = 44100
audio.target_sample_rate = sample_rate
audio.buffer_size = global_data.config["audio"]["buffer_size"]
audio.volume_presets = global_data.config["volume"]
audio.init_audio_device()
logger.info("Settings saved and audio device re-initialized")
return super().on_screen_end(next_screen)
return next_screen
def handle_input(self):
if is_l_kat_pressed():
audio.play_sound('kat', 'sound')
self.box_manager.move_left()
elif is_r_kat_pressed():
audio.play_sound('kat', 'sound')
self.box_manager.move_right()
elif is_l_don_pressed() or is_r_don_pressed():
audio.play_sound('don', 'sound')
box_name = self.box_manager.select_box()
if box_name == 'exit':
return self.on_screen_end("ENTRY")
def get_current_settings(self):
"""Get the current section's settings as a list"""
current_header = self.headers[self.header_index]
if current_header == 'Exit' or current_header not in self.config:
return []
return list(self.config[current_header].items())
def handle_boolean_toggle(self, section, key):
"""Toggle boolean values"""
self.config[section][key] = not self.config[section][key]
logger.info(f"Toggled boolean setting: {section}.{key} -> {self.config[section][key]}")
def handle_numeric_change(self, section, key, increment):
"""Handle numeric value changes"""
current_value = self.config[section][key]
# Define step sizes for different settings
step_sizes = {
'judge_offset': 1,
'visual_offset': 1,
'sample_rate': 1000,
}
step = step_sizes.get(key, 1)
new_value = current_value + (step * increment)
if key == 'sample_rate':
valid_rates = [-1, 22050, 44100, 48000, 88200, 96000]
current_idx = valid_rates.index(current_value) if current_value in valid_rates else 2
new_idx = max(0, min(len(valid_rates) - 1, current_idx + increment))
new_value = valid_rates[new_idx]
if key == 'buffer_size':
valid_sizes = [-1, 32, 64, 128, 256, 512, 1024]
current_idx = valid_sizes.index(current_value) if current_value in valid_sizes else 2
new_idx = max(0, min(len(valid_sizes) - 1, current_idx + increment))
new_value = valid_sizes[new_idx]
self.config[section][key] = new_value
logger.info(f"Changed numeric setting: {section}.{key} -> {new_value}")
def handle_string_cycle(self, section, key):
"""Cycle through predefined string values"""
current_value = self.config[section][key]
options = {
'language': ['ja', 'en'],
}
if key in options:
values = options[key]
try:
current_idx = values.index(current_value)
new_idx = (current_idx + 1) % len(values)
self.config[section][key] = values[new_idx]
except ValueError:
self.config[section][key] = values[0]
logger.info(f"Cycled string setting: {section}.{key} -> {self.config[section][key]}")
def handle_key_binding(self, section, key):
"""Handle key binding changes"""
self.editing_key = True
logger.info(f"Started key binding edit for: {section}.{key}")
def update_key_binding(self):
"""Update key binding based on input"""
key_pressed = ray.get_key_pressed()
if key_pressed != 0:
# Convert keycode to character
if 65 <= key_pressed <= 90: # A-Z
new_key = chr(key_pressed)
current_header = self.headers[self.header_index]
settings = self.get_current_settings()
if settings:
setting_key, _ = settings[self.setting_index]
self.config[current_header][setting_key] = [new_key]
self.editing_key = False
logger.info(f"Key binding updated: {current_header}.{setting_key} -> {new_key}")
elif key_pressed == global_data.config["keys"]["back_key"]:
self.editing_key = False
logger.info("Key binding edit cancelled")
def handle_gamepad_binding(self, section, key):
self.editing_gamepad = True
logger.info(f"Started gamepad binding edit for: {section}.{key}")
def update_gamepad_binding(self):
"""Update gamepad binding based on input"""
button_pressed = ray.get_gamepad_button_pressed()
if button_pressed != 0:
current_header = self.headers[self.header_index]
settings = self.get_current_settings()
if settings:
setting_key, _ = settings[self.setting_index]
self.config[current_header][setting_key] = [button_pressed]
self.editing_gamepad = False
logger.info(f"Gamepad binding updated: {current_header}.{setting_key} -> {button_pressed}")
if ray.is_key_pressed(global_data.config["keys"]["back_key"]):
self.editing_gamepad = False
logger.info("Gamepad binding edit cancelled")
def update(self):
super().update()
current_time = get_current_ms()
self.indicator.update(current_time)
self.box_manager.update(current_time)
return self.handle_input()
# Handle key binding editing
if self.editing_key:
self.update_key_binding()
return
if self.editing_gamepad:
self.update_gamepad_binding()
return
current_header = self.headers[self.header_index]
# Exit handling
if current_header == 'Exit' and (is_l_don_pressed() or is_r_don_pressed()):
logger.info("Exiting settings screen")
return self.on_screen_end("ENTRY")
# Navigation between sections
if not self.in_setting_edit:
if is_r_kat_pressed():
self.header_index = (self.header_index + 1) % len(self.headers)
self.setting_index = 0
logger.info(f"Navigated to next section: {self.headers[self.header_index]}")
elif is_l_kat_pressed():
self.header_index = (self.header_index - 1) % len(self.headers)
self.setting_index = 0
logger.info(f"Navigated to previous section: {self.headers[self.header_index]}")
elif (is_l_don_pressed() or is_r_don_pressed()) and current_header != 'Exit':
self.in_setting_edit = True
logger.info(f"Entered section edit: {current_header}")
else:
# Navigation within settings
settings = self.get_current_settings()
if not settings:
self.in_setting_edit = False
return
if is_r_kat_pressed():
self.setting_index = (self.setting_index + 1) % len(settings)
logger.info(f"Navigated to next setting: {settings[self.setting_index][0]}")
elif is_l_kat_pressed():
self.setting_index = (self.setting_index - 1) % len(settings)
logger.info(f"Navigated to previous setting: {settings[self.setting_index][0]}")
elif is_r_don_pressed():
# Modify setting value
setting_key, setting_value = settings[self.setting_index]
if isinstance(setting_value, bool):
self.handle_boolean_toggle(current_header, setting_key)
elif isinstance(setting_value, (int, float)):
self.handle_numeric_change(current_header, setting_key, 1)
elif isinstance(setting_value, str):
if 'keys' in current_header:
self.handle_key_binding(current_header, setting_key)
elif 'gamepad' in current_header:
self.handle_gamepad_binding(current_header, setting_key)
else:
self.handle_string_cycle(current_header, setting_key)
elif isinstance(setting_value, list) and len(setting_value) > 0:
if isinstance(setting_value[0], str) and len(setting_value[0]) == 1:
# Key binding
self.handle_key_binding(current_header, setting_key)
elif isinstance(setting_value[0], int):
self.handle_gamepad_binding(current_header, setting_key)
elif is_l_don_pressed():
# Modify setting value (reverse direction for numeric)
setting_key, setting_value = settings[self.setting_index]
if isinstance(setting_value, bool):
self.handle_boolean_toggle(current_header, setting_key)
elif isinstance(setting_value, (int, float)):
self.handle_numeric_change(current_header, setting_key, -1)
elif isinstance(setting_value, str):
if ('keys' not in current_header) and ('gamepad' not in current_header):
self.handle_string_cycle(current_header, setting_key)
elif ray.is_key_pressed(global_data.config["keys"]["back_key"]):
self.in_setting_edit = False
logger.info("Exited section edit")
def draw(self):
tex.draw_texture('background', 'background')
self.box_manager.draw()
tex.draw_texture('background', 'footer')
self.indicator.draw(tex.skin_config['song_select_indicator'].x, tex.skin_config['song_select_indicator'].y)
self.coin_overlay.draw()
self.allnet_indicator.draw()
ray.draw_rectangle(0, 0, tex.screen_width, tex.screen_height, ray.BLACK)
# Draw title
ray.draw_rectangle(0, 0, tex.screen_width, tex.screen_height, ray.BLACK)
ray.draw_text("SETTINGS", 20, 20, 30, ray.WHITE)
# Draw section headers
current_header = self.headers[self.header_index]
for i, key in enumerate(self.headers):
color = ray.GREEN
if key == current_header:
color = ray.YELLOW if not self.in_setting_edit else ray.ORANGE
ray.draw_text(f'{key}', 20, i*25 + 70, 20, color)
# Draw current section settings
if current_header != 'Exit' and current_header in self.config:
settings = self.get_current_settings()
# Draw settings list
for i, (key, value) in enumerate(settings):
color = ray.GREEN
if self.in_setting_edit and i == self.setting_index:
color = ray.YELLOW
# Format value display
if isinstance(value, list):
display_value = ', '.join(map(str, value))
else:
display_value = str(value)
if key == 'device_type' and not isinstance(value, list):
display_value = f'{display_value} ({audio.get_host_api_name(value)})'
ray.draw_text(f'{key}: {display_value}', 250, i*25 + 70, 20, color)
# Draw instructions
y_offset = len(settings) * 25 + 150
if not self.in_setting_edit:
ray.draw_text("Don/Kat: Navigate sections", 20, y_offset, 16, ray.GRAY)
ray.draw_text("L/R Don: Enter section", 20, y_offset + 20, 16, ray.GRAY)
else:
ray.draw_text("Don/Kat: Navigate settings", 20, y_offset, 16, ray.GRAY)
ray.draw_text("L/R Don: Modify value", 20, y_offset + 20, 16, ray.GRAY)
ray.draw_text("ESC: Back to sections", 20, y_offset + 40, 16, ray.GRAY)
if self.editing_key:
ray.draw_text("Press a key to bind (ESC to cancel)", 20, y_offset + 60, 16, ray.RED)
else:
# Draw exit instruction
ray.draw_text("Press Don to exit settings", 250, 100, 20, ray.GREEN)

33
scenes/song_select.py
View File

@@ -16,7 +16,6 @@ from libs.file_navigator import (
GenreIndex,
SongBox,
SongFile,
SongFileOsu,
navigator,
)
from libs.global_data import Difficulty, Modifiers, PlayerNum
@@ -102,7 +101,7 @@ class SongSelectScreen(Screen):
self.navigator.mark_crowns_dirty_for_song(selected_song)
curr_item = self.navigator.get_current_item()
if not isinstance(curr_item, Directory):
if isinstance(curr_item, SongFile):
curr_item.box.get_scores()
self.navigator.add_recent()
@@ -117,7 +116,7 @@ class SongSelectScreen(Screen):
ray.set_shader_value(self.shader, source_loc, source_color, SHADER_UNIFORM_VEC3)
ray.set_shader_value(self.shader, target_loc, target_color, SHADER_UNIFORM_VEC3)
def finalize_song(self, current_item: SongFile | SongFileOsu):
def finalize_song(self, current_item: SongFile):
global_data.session_data[global_data.player_num].selected_song = current_item.path
global_data.session_data[global_data.player_num].song_hash = global_data.song_hashes[current_item.hash][0]["diff_hashes"][self.player_1.selected_difficulty]
global_data.session_data[global_data.player_num].selected_difficulty = self.player_1.selected_difficulty
@@ -127,7 +126,7 @@ class SongSelectScreen(Screen):
self.screen_init = False
self.reset_demo_music()
current_item = self.navigator.get_current_item()
if (isinstance(current_item, SongFile) or isinstance(current_item, SongFileOsu)) and self.player_1.is_ready:
if isinstance(current_item, SongFile) and self.player_1.is_ready:
self.finalize_song(current_item)
self.player_1.nameplate.unload()
if isinstance(current_item.box, SongBox) and current_item.box.yellow_box is not None:
@@ -184,7 +183,7 @@ class SongSelectScreen(Screen):
audio.stop_sound('bgm')
return
selected_song = self.navigator.select_current_item()
if isinstance(selected_song, SongFile) or isinstance(selected_song, SongFileOsu):
if isinstance(selected_song, SongFile):
self.state = State.SONG_SELECTED
self.player_1.on_song_selected(selected_song)
audio.play_sound('don', 'sound')
@@ -285,12 +284,12 @@ class SongSelectScreen(Screen):
def check_for_selection(self):
if self.player_1.selected_diff_highlight_fade.is_finished and not audio.is_sound_playing(f'voice_start_song_{global_data.player_num}p') and self.game_transition is None:
selected_song = self.navigator.get_current_item()
if not isinstance(selected_song, SongFile) and not isinstance(selected_song, SongFileOsu):
if not isinstance(selected_song, SongFile):
raise Exception("picked directory")
title = selected_song.parser.metadata.title.get(
title = selected_song.tja.metadata.title.get(
global_data.config['general']['language'], '')
subtitle = selected_song.parser.metadata.subtitle.get(
subtitle = selected_song.tja.metadata.subtitle.get(
global_data.config['general']['language'], '')
self.game_transition = Transition(title, subtitle)
self.game_transition.start()
@@ -359,12 +358,12 @@ class SongSelectScreen(Screen):
if not isinstance(song, Directory) and song.box.is_open:
if self.demo_song is None and current_time >= song.box.wait + (83.33*3):
song.box.get_scores()
if song.parser.metadata.wave.exists() and song.parser.metadata.wave.is_file():
self.demo_song = audio.load_music_stream(song.parser.metadata.wave, 'demo_song')
if song.tja.metadata.wave.exists() and song.tja.metadata.wave.is_file():
self.demo_song = audio.load_music_stream(song.tja.metadata.wave, 'demo_song')
audio.play_music_stream(self.demo_song, 'music')
audio.seek_music_stream(self.demo_song, song.parser.metadata.demostart)
audio.seek_music_stream(self.demo_song, song.tja.metadata.demostart)
audio.stop_sound('bgm')
logger.info(f"Demo song loaded and playing for {song.parser.metadata.title}")
logger.info(f"Demo song loaded and playing for {song.tja.metadata.title}")
if song.box.is_open:
current_box = song.box
if not isinstance(current_box, BackBox) and current_time >= song.box.wait + (83.33*3):
@@ -446,7 +445,7 @@ class SongSelectScreen(Screen):
if self.state == State.BROWSING and self.navigator.items != []:
curr_item = self.navigator.get_current_item()
if not isinstance(curr_item, Directory):
if isinstance(curr_item, SongFile):
curr_item.box.draw_score_history()
self.draw_overlay()
@@ -509,10 +508,10 @@ class SongSelectPlayer:
def on_song_selected(self, selected_song):
"""Called when a song is selected"""
if Difficulty.URA not in selected_song.parser.metadata.course_data:
if Difficulty.URA not in selected_song.tja.metadata.course_data:
self.is_ura = False
elif (Difficulty.URA in selected_song.parser.metadata.course_data and
Difficulty.ONI not in selected_song.parser.metadata.course_data):
elif (Difficulty.URA in selected_song.tja.metadata.course_data and
Difficulty.ONI not in selected_song.tja.metadata.course_data):
self.is_ura = True
def handle_input_browsing(self, last_moved, selected_item):
@@ -646,7 +645,7 @@ class SongSelectPlayer:
if is_l_kat_pressed(self.player_num) or is_r_kat_pressed(self.player_num):
audio.play_sound('kat', 'sound')
selected_song = current_item
diffs = sorted(selected_song.parser.metadata.course_data)
diffs = sorted(selected_song.tja.metadata.course_data)
prev_diff = self.selected_difficulty
ret_val = None

24
scenes/two_player/game.py
View File

@@ -6,7 +6,7 @@ import pyray as ray
from libs.audio import audio
from libs.global_data import PlayerNum
from libs.parsers.tja import TJAParser
from libs.tja import TJAParser
from libs.utils import get_current_ms, global_data
from libs.video import VideoPlayer
from scenes.game import (
@@ -24,7 +24,7 @@ logger = logging.getLogger(__name__)
class TwoPlayerGameScreen(GameScreen):
def on_screen_start(self):
super().on_screen_start()
scene_preset = self.parser.metadata.scene_preset
scene_preset = self.tja.metadata.scene_preset
if self.background is not None:
self.background.unload()
self.background = Background(PlayerNum.TWO_PLAYER, self.bpm, scene_preset=scene_preset)
@@ -83,20 +83,20 @@ class TwoPlayerGameScreen(GameScreen):
def init_tja(self, song: Path):
"""Initialize the TJA file"""
self.parser = TJAParser(song, start_delay=self.start_delay)
if self.parser.metadata.bgmovie != Path() and self.parser.metadata.bgmovie.exists():
self.movie = VideoPlayer(self.parser.metadata.bgmovie)
self.tja = TJAParser(song, start_delay=self.start_delay)
if self.tja.metadata.bgmovie != Path() and self.tja.metadata.bgmovie.exists():
self.movie = VideoPlayer(self.tja.metadata.bgmovie)
self.movie.set_volume(0.0)
else:
self.movie = None
global_data.session_data[PlayerNum.P1].song_title = self.parser.metadata.title.get(global_data.config['general']['language'].lower(), self.parser.metadata.title['en'])
if self.parser.metadata.wave.exists() and self.parser.metadata.wave.is_file() and self.song_music is None:
self.song_music = audio.load_music_stream(self.parser.metadata.wave, 'song')
global_data.session_data[PlayerNum.P1].song_title = self.tja.metadata.title.get(global_data.config['general']['language'].lower(), self.tja.metadata.title['en'])
if self.tja.metadata.wave.exists() and self.tja.metadata.wave.is_file() and self.song_music is None:
self.song_music = audio.load_music_stream(self.tja.metadata.wave, 'song')
tja_copy = copy.deepcopy(self.parser)
self.player_1 = Player(self.parser, PlayerNum.P1, global_data.session_data[PlayerNum.P1].selected_difficulty, False, global_data.modifiers[PlayerNum.P1])
tja_copy = copy.deepcopy(self.tja)
self.player_1 = Player(self.tja, PlayerNum.P1, global_data.session_data[PlayerNum.P1].selected_difficulty, False, global_data.modifiers[PlayerNum.P1])
self.player_2 = Player(tja_copy, PlayerNum.P2, global_data.session_data[PlayerNum.P2].selected_difficulty, True, global_data.modifiers[PlayerNum.P2])
self.start_ms = (get_current_ms() - self.parser.metadata.offset*1000)
self.start_ms = (get_current_ms() - self.tja.metadata.offset*1000)
logger.info(f"TJA initialized for two-player song: {song}")
def spawn_ending_anims(self):
@@ -122,7 +122,7 @@ class TwoPlayerGameScreen(GameScreen):
if self.transition.is_finished:
self.start_song(self.current_ms)
else:
self.start_ms = current_time - self.parser.metadata.offset*1000
self.start_ms = current_time - self.tja.metadata.offset*1000
self.update_background(current_time)
if self.song_music is not None:

4
scenes/two_player/song_select.py
View File

@@ -167,9 +167,9 @@ class TwoPlayerSongSelectScreen(SongSelectScreen):
if not isinstance(selected_song, SongFile):
raise Exception("picked directory")
title = selected_song.parser.metadata.title.get(
title = selected_song.tja.metadata.title.get(
global_data.config['general']['language'], '')
subtitle = selected_song.parser.metadata.subtitle.get(
subtitle = selected_song.tja.metadata.subtitle.get(
global_data.config['general']['language'], '')
self.game_transition = Transition(title, subtitle)
self.game_transition.start()