unlikely fix

PyTaiko.py

@@ -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(pyray.get_font_default(), 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)

Songs/15 Recently Played/song_list.txt

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

config.toml

@@ -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
@@ -64,7 +64,7 @@ device_type = 0
 sample_rate = 44100
 # buffer_size: Size in samples per audio buffer
 # - 0 = let driver choose (may result in very small buffers with ASIO, typically 64)
-buffer_size = 128
+buffer_size = 32
 
 [volume]
 sound = 1.0

libs/animation.py

@@ -3,8 +3,17 @@ from typing import Any, Optional
 
 from libs.global_data import global_data
 
-def get_current_ms() -> float:
+
-    return time.time() * 1000
+def rounded(num: float) -> int:
+    sign = 1 if (num >= 0) else -1
+    num = abs(num)
+    result = int(num)
+    if (num - result >= 0.5):
+        result += 1
+    return sign * result
+
+def get_current_ms() -> int:
+    return rounded(time.time() * 1000)
 
 
 class BaseAnimation():
@@ -75,22 +84,6 @@ class BaseAnimation():
         self.restart()
         self.pause()
 
-    def copy(self):
-        """Create a copy of the animation with reset state."""
-        new_anim = self.__class__.__new__(self.__class__)
-        new_anim.duration = self.duration
-        new_anim.delay = self.delay_saved
-        new_anim.delay_saved = self.delay_saved
-        new_anim.start_ms = get_current_ms()
-        new_anim.is_finished = False
-        new_anim.attribute = 0
-        new_anim.is_started = False
-        new_anim.is_reversing = False
-        new_anim.unlocked = False
-        new_anim.loop = self.loop
-        new_anim.lock_input = self.lock_input
-        return new_anim
-
     def _ease_in(self, progress: float, ease_type: str) -> float:
         if ease_type == "quadratic":
             return progress * progress
@@ -140,20 +133,6 @@ class FadeAnimation(BaseAnimation):
         self.final_opacity = self.final_opacity_saved
         self.attribute = self.initial_opacity
 
-    def copy(self):
-        """Create a copy of the fade animation with reset state."""
-        new_anim = super().copy()
-        new_anim.initial_opacity = self.initial_opacity_saved
-        new_anim.initial_opacity_saved = self.initial_opacity_saved
-        new_anim.final_opacity = self.final_opacity_saved
-        new_anim.final_opacity_saved = self.final_opacity_saved
-        new_anim.ease_in = self.ease_in
-        new_anim.ease_out = self.ease_out
-        new_anim.reverse_delay = self.reverse_delay_saved
-        new_anim.reverse_delay_saved = self.reverse_delay_saved
-        new_anim.attribute = self.initial_opacity_saved
-        return new_anim
-
     def update(self, current_time_ms: float) -> None:
         if not self.is_started:
             return
@@ -202,20 +181,6 @@ class MoveAnimation(BaseAnimation):
         self.start_position = self.start_position_saved
         self.attribute = self.start_position
 
-    def copy(self):
-        """Create a copy of the move animation with reset state."""
-        new_anim = super().copy()
-        new_anim.reverse_delay = self.reverse_delay_saved
-        new_anim.reverse_delay_saved = self.reverse_delay_saved
-        new_anim.total_distance = self.total_distance_saved
-        new_anim.total_distance_saved = self.total_distance_saved
-        new_anim.start_position = self.start_position_saved
-        new_anim.start_position_saved = self.start_position_saved
-        new_anim.ease_in = self.ease_in
-        new_anim.ease_out = self.ease_out
-        new_anim.attribute = self.start_position_saved
-        return new_anim
-
     def update(self, current_time_ms: float) -> None:
         if not self.is_started:
             return
@@ -252,13 +217,6 @@ class TextureChangeAnimation(BaseAnimation):
         super().reset()
         self.attribute = self.textures[0][2]
 
-    def copy(self):
-        """Create a copy of the texture change animation with reset state."""
-        new_anim = super().copy()
-        new_anim.textures = self.textures  # List of tuples, can be shared
-        new_anim.attribute = self.textures[0][2]
-        return new_anim
-
     def update(self, current_time_ms: float) -> None:
         if not self.is_started:
             return
@@ -276,10 +234,6 @@ class TextureChangeAnimation(BaseAnimation):
             self.is_finished = True
 
 class TextStretchAnimation(BaseAnimation):
-    def copy(self):
-        """Create a copy of the text stretch animation with reset state."""
-        return super().copy()
-
     def update(self, current_time_ms: float) -> None:
         if not self.is_started:
             return
@@ -321,20 +275,6 @@ class TextureResizeAnimation(BaseAnimation):
         self.initial_size = self.initial_size_saved
         self.final_size = self.final_size_saved
 
-    def copy(self):
-        """Create a copy of the texture resize animation with reset state."""
-        new_anim = super().copy()
-        new_anim.initial_size = self.initial_size_saved
-        new_anim.initial_size_saved = self.initial_size_saved
-        new_anim.final_size = self.final_size_saved
-        new_anim.final_size_saved = self.final_size_saved
-        new_anim.reverse_delay = self.reverse_delay_saved
-        new_anim.reverse_delay_saved = self.reverse_delay_saved
-        new_anim.ease_in = self.ease_in
-        new_anim.ease_out = self.ease_out
-        new_anim.attribute = self.initial_size_saved
-        return new_anim
-
 
     def update(self, current_time_ms: float) -> None:
         if not self.is_started:

libs/audio.py

@@ -92,7 +92,6 @@ ffi.cdef("""
     void resume_music_stream(music music);
     void stop_music_stream(music music);
     void seek_music_stream(music music, float position);
-    bool music_stream_needs_update(music music);
     void update_music_stream(music music);
     bool is_music_stream_playing(music music);
     void set_music_volume(music music, float volume);
@@ -360,18 +359,10 @@ class AudioEngine:
         else:
             logger.warning(f"Music stream {name} not found")
 
-    def music_stream_needs_update(self, name: str) -> bool:
-        """Check if a music stream needs updating (buffers need refilling)"""
-        if name in self.music_streams:
-            music = self.music_streams[name]
-            return lib.music_stream_needs_update(music) # type: ignore
-        return False
-
     def update_music_stream(self, name: str) -> None:
-        """Update a music stream (only if buffers need refilling)"""
+        """Update a music stream"""
         if name in self.music_streams:
             music = self.music_streams[name]
-            if lib.music_stream_needs_update(music): # type: ignore
             lib.update_music_stream(music) # type: ignore
         else:
             logger.warning(f"Music stream {name} not found")

libs/audio/audio.c

@@ -175,7 +175,6 @@ void pause_music_stream(music music);
 void resume_music_stream(music music);
 void stop_music_stream(music music);
 void seek_music_stream(music music, float position);
-bool music_stream_needs_update(music music);
 void update_music_stream(music music);
 bool is_music_stream_playing(music music);
 void set_music_volume(music music, float volume);
@@ -1065,17 +1064,6 @@ void seek_music_stream(music music, float position) {
     pthread_mutex_unlock(&AUDIO.System.lock);
 }
 
-bool music_stream_needs_update(music music) {
-    if (music.stream.buffer == NULL || music.ctxData == NULL) return false;
-
-    pthread_mutex_lock(&AUDIO.System.lock);
-    bool needs_update = music.stream.buffer->isSubBufferProcessed[0] ||
-                        music.stream.buffer->isSubBufferProcessed[1];
-    pthread_mutex_unlock(&AUDIO.System.lock);
-
-    return needs_update;
-}
-
 void update_music_stream(music music) {
     if (music.stream.buffer == NULL || music.ctxData == NULL) return;
 
@@ -1083,41 +1071,33 @@ void update_music_stream(music music) {
     SNDFILE *sndFile = ctx->snd_file;
     if (sndFile == NULL) return;
 
-    bool needs_refill[2];
+    for (int i = 0; i < 2; i++) {
         pthread_mutex_lock(&AUDIO.System.lock);
-    needs_refill[0] = music.stream.buffer->isSubBufferProcessed[0];
+        bool needs_refill = music.stream.buffer->isSubBufferProcessed[i];
-    needs_refill[1] = music.stream.buffer->isSubBufferProcessed[1];
         pthread_mutex_unlock(&AUDIO.System.lock);
 
-    if (!needs_refill[0] && !needs_refill[1]) return;
+        if (needs_refill) {
-
             unsigned int subBufferSizeFrames = music.stream.buffer->sizeInFrames / 2;
-    float *buffer_data = (float *)music.stream.buffer->data;
-    bool needs_resampling = (ctx->resampler != NULL);
-    bool needs_mono_to_stereo = (music.stream.channels == 1 && AUDIO_DEVICE_CHANNELS == 2);
 
             unsigned int frames_to_read = subBufferSizeFrames;
-    if (needs_resampling) {
+            if (ctx->resampler) {
                 frames_to_read = (unsigned int)(subBufferSizeFrames / ctx->src_ratio) + 1;
             }
 
-    size_t required_size = frames_to_read * music.stream.channels * sizeof(float);
+            if (AUDIO.System.pcmBufferSize < frames_to_read * music.stream.channels * sizeof(float)) {
-    if (AUDIO.System.pcmBufferSize < required_size) {
                 FREE(AUDIO.System.pcmBuffer);
-        AUDIO.System.pcmBuffer = calloc(1, required_size);
+                AUDIO.System.pcmBuffer = calloc(1, frames_to_read * music.stream.channels * sizeof(float));
-        AUDIO.System.pcmBufferSize = required_size;
+                AUDIO.System.pcmBufferSize = frames_to_read * music.stream.channels * sizeof(float);
             }
 
-    for (int i = 0; i < 2; i++) {
-        if (!needs_refill[i]) continue;
-
             sf_count_t frames_read = sf_readf_float(sndFile, (float*)AUDIO.System.pcmBuffer, frames_to_read);
 
             unsigned int subBufferOffset = i * subBufferSizeFrames * AUDIO_DEVICE_CHANNELS;
+            float *buffer_data = (float *)music.stream.buffer->data;
             float *input_ptr = (float *)AUDIO.System.pcmBuffer;
             sf_count_t frames_written = 0;
 
-        if (needs_resampling) {
+            if (ctx->resampler) {
                 spx_uint32_t in_len = frames_read;
                 spx_uint32_t out_len = subBufferSizeFrames;
 
@@ -1135,7 +1115,7 @@ void update_music_stream(music music) {
 
                 frames_written = out_len;
             } else {
-            if (needs_mono_to_stereo) {
+                if (music.stream.channels == 1 && AUDIO_DEVICE_CHANNELS == 2) {
                     for (int j = 0; j < frames_read; j++) {
                         buffer_data[subBufferOffset + j*2] = input_ptr[j];
                         buffer_data[subBufferOffset + j*2 + 1] = input_ptr[j];
@@ -1151,12 +1131,12 @@ void update_music_stream(music music) {
                 unsigned int size = (subBufferSizeFrames - frames_written) * AUDIO_DEVICE_CHANNELS * sizeof(float);
                 memset(buffer_data + offset, 0, size);
             }
-    }
 
             pthread_mutex_lock(&AUDIO.System.lock);
-    if (needs_refill[0]) music.stream.buffer->isSubBufferProcessed[0] = false;
+            music.stream.buffer->isSubBufferProcessed[i] = false;
-    if (needs_refill[1]) music.stream.buffer->isSubBufferProcessed[1] = false;
             pthread_mutex_unlock(&AUDIO.System.lock);
+        }
+    }
 }
 
 bool is_music_stream_playing(music music) {

libs/file_navigator.py

@@ -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:
+            if self.tja.metadata.course_data:
-                hash_values = [self.hash[diff] for diff in self.parser.metadata.course_data if diff in self.hash]
+                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
+            self.tja.ex_data.new = True
-        title = self.parser.metadata.title.get(global_data.config['general']['language'].lower(), self.parser.metadata.title['en'])
+        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 = 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()
-
-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.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:
+                    for course in song_obj.tja.metadata.course_data:
-                        level = song_obj.parser.metadata.course_data[course].level
+                        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')
+                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.parser.metadata.title['en']} {song.parser.metadata.subtitle['en']}")
+            logger.info(f"Added Favorite: {song.hash} {song.tja.metadata.title['en']} {song.tja.metadata.subtitle['en']}")
         return True
 
 navigator = FileNavigator()

libs/parsers/osz.py

@@ -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(encoding='utf-8'), 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 0 < points[1] < 60000:
-                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()

libs/screen.py

@@ -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

libs/song_hash.py

@@ -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.tja import NoteList, TJAParser, test_encodings
-from libs.parsers.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:
+            for diff in tja.metadata.course_data:
-                    diff_notes, branch_m, branch_e, branch_n = TJAParser.notes_to_position(TJAParser(parser.file_path), diff)
+                diff_notes, branch_m, branch_e, branch_n = TJAParser.notes_to_position(TJAParser(tja.file_path), diff)
-                    diff_hashes[diff] = parser.hash_note_data(diff_notes)
+                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,
+            "title": tja.metadata.title,
-            "subtitle": parser.metadata.subtitle,
+            "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)
+        en_name = tja.metadata.title.get('en', '') if isinstance(tja.metadata.title, dict) else str(tja.metadata.title)
-        jp_name = parser.metadata.title.get('ja', '') if isinstance(parser.metadata.title, dict) else ''
+        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():

libs/texture.py

@@ -1,3 +1,4 @@
+import copy
 import json
 import logging
 import sys
@@ -127,7 +128,7 @@ class TextureWrapper:
         if index not in self.animations:
             raise Exception(f"Unable to find id {index} in loaded animations")
         if is_copy:
-            new_anim = self.animations[index].copy()
+            new_anim = copy.deepcopy(self.animations[index])
             if self.animations[index].loop:
                 new_anim.start()
             return new_anim

libs/tja.py

@@ -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

libs/utils.py

@@ -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__)
@@ -40,9 +40,9 @@ def rounded(num: float) -> int:
         result += 1
     return sign * result
 
-def get_current_ms() -> float:
+def get_current_ms() -> int:
     """Get the current time in milliseconds"""
-    return time.time() * 1000
+    return rounded(time.time() * 1000)
 
 def strip_comments(code: str) -> str:
     """Strip comments from a string of code"""
@@ -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):
@@ -175,12 +189,6 @@ class OutlinedText:
 
         self.default_src = ray.Rectangle(0, 0, self.texture.width, self.texture.height)
 
-        self._last_outline_color = None
-        self._last_color = None
-        self._last_fade = None
-        self._outline_color_alloc = None
-        self._alpha_value = None
-
     def _hash_text(self, text: str, font_size: int, color: ray.Color, vertical: bool):
         n = hashlib.sha256()
         n.update(text.encode('utf-8'))
@@ -412,46 +420,39 @@ class OutlinedText:
             rotation (float): The rotation angle of the text.
             fade (float): The fade factor to apply to the text.
         """
-        if self._last_outline_color != outline_color:
         if isinstance(outline_color, tuple):
-                self._outline_color_alloc = ray.ffi.new("float[4]", [
+            outline_color_alloc = ray.ffi.new("float[4]", [
                 outline_color[0] / 255.0,
                 outline_color[1] / 255.0,
                 outline_color[2] / 255.0,
                 outline_color[3] / 255.0
             ])
         else:
-                self._outline_color_alloc = ray.ffi.new("float[4]", [
+            outline_color_alloc = ray.ffi.new("float[4]", [
                 outline_color.r / 255.0,
                 outline_color.g / 255.0,
                 outline_color.b / 255.0,
                 outline_color.a / 255.0
             ])
-            ray.set_shader_value(self.shader, self.outline_color_loc, self._outline_color_alloc, SHADER_UNIFORM_VEC4)
+        ray.set_shader_value(self.shader, self.outline_color_loc, outline_color_alloc, SHADER_UNIFORM_VEC4)
-            self._last_outline_color = outline_color
-
-        if self._last_color != color or self._last_fade != fade:
         if isinstance(color, tuple):
-                self._alpha_value = ray.ffi.new('float*', min(fade * 255, color[3]) / 255.0)
+            alpha_value = ray.ffi.new('float*', min(fade * 255, color[3]) / 255.0)
         else:
-                self._alpha_value = ray.ffi.new('float*', min(fade * 255, color.a) / 255.0)
+            alpha_value = ray.ffi.new('float*', min(fade * 255, color.a) / 255.0)
-            ray.set_shader_value(self.shader, self.alpha_loc, self._alpha_value, SHADER_UNIFORM_FLOAT)
-            self._last_color = color
-            self._last_fade = fade
-
         if fade != 1.1:
             final_color = ray.fade(color, fade)
         else:
             final_color = color
+        ray.set_shader_value(self.shader, self.alpha_loc, alpha_value, SHADER_UNIFORM_FLOAT)
         if not self.vertical:
             offset = (10 * global_tex.screen_scale)-10
         else:
             offset = 0
         dest_rect = ray.Rectangle(x, y+offset, self.texture.width+x2, self.texture.height+y2)
-        if self.outline_thickness > 0 and self._last_color != ray.BLANK:
+        if self.outline_thickness > 0:
             ray.begin_shader_mode(self.shader)
         ray.draw_texture_pro(self.texture, self.default_src, dest_rect, origin, rotation, final_color)
-        if self.outline_thickness > 0 and self._last_color != ray.BLANK:
+        if self.outline_thickness > 0:
             ray.end_shader_mode()
 
     def unload(self):

libs/video.py

@@ -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):
@@ -198,26 +186,10 @@ class VideoPlayer:
     def draw(self):
         """Draw video frames to the raylib canvas"""
         if self.texture is not None:
-            source = (0, 0, self.texture.width, self.texture.height)
-            texture_aspect = self.texture.width / self.texture.height
-            screen_aspect = tex.screen_width / tex.screen_height
-            if texture_aspect > screen_aspect:
-                dest_width = tex.screen_width
-                dest_height = tex.screen_width / texture_aspect
-                dest_x = 0
-                dest_y = (tex.screen_height - dest_height) / 2
-            else:
-                dest_height = tex.screen_height
-                dest_width = tex.screen_height * texture_aspect
-                dest_x = (tex.screen_width - dest_width) / 2
-                dest_y = 0
-
-            destination = (dest_x, dest_y, dest_width, dest_height)
-            ray.ClearBackground(ray.BLACK)
             ray.DrawTexturePro(
                 self.texture,
-                source,
+                (0, 0, self.texture.width, self.texture.height),
-                destination,
+                (0, 0, tex.screen_width, tex.screen_height),
                 (0, 0),
                 0,
                 ray.WHITE
@@ -225,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()
 

scenes/ai_battle/game.py

@@ -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'])
+        session_data.song_title = self.tja.metadata.title.get(global_data.config['general']['language'].lower(), self.tja.metadata.title['en'])
-        if self.parser.metadata.wave.exists() and self.parser.metadata.wave.is_file() and self.song_music is None:
+        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.parser.metadata.wave, 'song')
+            self.song_music = audio.load_music_stream(self.tja.metadata.wave, 'song')
 
-        tja_copy = copy.deepcopy(self.parser)
+        tja_copy = copy.deepcopy(self.tja)
-        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 = 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.parser.metadata.course_data[self.player_1.difficulty].level, self.player_1.total_notes, self.player_1.is_2p)
+        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.start_ms = (get_current_ms() - self.tja.metadata.offset*1000)
-        self.precise_start = time.time() - self.parser.metadata.offset
+        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)

scenes/ai_battle/song_select.py

@@ -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
 

scenes/dan/game_dan.py

@@ -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:
+        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.parser.metadata.wave, 'song')
+            self.song_music = audio.load_music_stream(self.tja.metadata.wave, 'song')
-        self.player_1.parser = self.parser
+        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.song_info = SongInfo(self.tja.metadata.title.get(global_data.config["general"]["language"], "en"), genre_index)
-        self.start_ms = (get_current_ms() - self.parser.metadata.offset*1000)
+        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:

scenes/game.py

@@ -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(), '')
+        subtitle = self.tja.metadata.subtitle.get(global_data.config['general']['language'].lower(), '')
-        self.bpm = self.parser.metadata.bpm
+        self.bpm = self.tja.metadata.bpm
-        scene_preset = self.parser.metadata.scene_preset
+        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.tja = TJAParser(song, start_delay=self.start_delay)
-            self.start_delay = 0
+        if self.tja.metadata.bgmovie != Path() and self.tja.metadata.bgmovie.exists():
-            self.parser = OsuParser(song)
+            self.movie = VideoPlayer(self.tja.metadata.bgmovie)
-        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)
         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'])
+        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.parser.metadata.wave.exists() and self.parser.metadata.wave.is_file() and self.song_music is None:
+        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.parser.metadata.wave, 'song')
+            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.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.parser.metadata.offset*1000
+        self.start_ms = get_current_ms() - self.tja.metadata.offset*1000
-        self.precise_start = time.time() - self.parser.metadata.offset
+        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'],
+                data = (hash, self.tja.metadata.title['en'],
-                        self.parser.metadata.title.get('ja', ''), self.player_1.difficulty,
+                        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)
@@ -314,9 +309,7 @@ class GameScreen(Screen):
 
     def draw_overlay(self):
         self.song_info.draw()
-        if not self.transition.is_finished:
         self.transition.draw()
-        if self.result_transition.is_started:
         self.result_transition.draw()
         self.allnet_indicator.draw()
 
@@ -337,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
@@ -345,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()
 
@@ -376,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 = BranchIndicator(self.is_2p) if tja and tja.metadata.course_data[self.difficulty].is_branching else None
-            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.ending_anim: Optional[FailAnimation | ClearAnimation | FCAnimation] = None
         self.is_gogo_time = False
         plate_info = global_data.config[f'nameplate_{self.is_2p+1}p']
@@ -391,10 +381,7 @@ class Player:
             self.judge_counter = None
 
         self.input_log: dict[float, str] = dict()
-        if not parser.metadata.course_data:
+        stars = tja.metadata.course_data[self.difficulty].level
-            stars = 10
-        else:
-            stars = parser.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] = []
 
@@ -427,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}])
@@ -446,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)
@@ -536,8 +524,8 @@ class Player:
         self.draw_note_list.extend(branch_section.draw_notes)
         self.draw_bar_list.extend(branch_section.bars)
         self.play_notes = deque(sorted(self.play_notes))
-        self.draw_note_list = deque(sorted(self.draw_note_list, key=lambda x: x.load_ms))
+        self.draw_note_list = deque(sorted(self.draw_note_list, key=lambda x: x.hit_ms))
-        self.draw_bar_list = deque(sorted(self.draw_bar_list, key=lambda x: x.load_ms))
+        self.draw_bar_list = deque(sorted(self.draw_bar_list, key=lambda x: x.hit_ms))
         total_don = [note for note in self.play_notes if note.type in {NoteType.DON, NoteType.DON_L}]
         total_kat = [note for note in self.play_notes if note.type in {NoteType.KAT, NoteType.KAT_L}]
         total_other = [note for note in self.play_notes if note.type not in {NoteType.DON, NoteType.DON_L, NoteType.KAT, NoteType.KAT_L}]
@@ -863,7 +851,6 @@ class Player:
         if background is not None:
             background.add_renda()
         self.score += 100
-        if len(self.base_score_list) < 5:
         self.base_score_list.append(ScoreCounterAnimation(self.player_num, 100, self.is_2p))
         if not self.current_notes_draw:
             return
@@ -883,7 +870,6 @@ class Player:
         self.curr_balloon_count += 1
         self.total_drumroll += 1
         self.score += 100
-        if len(self.base_score_list) < 5:
         self.base_score_list.append(ScoreCounterAnimation(self.player_num, 100, self.is_2p))
         if self.curr_balloon_count == note.count:
             self.is_balloon = False
@@ -958,12 +944,10 @@ class Player:
 
             big = curr_note.type == NoteType.DON_L or curr_note.type == NoteType.KAT_L
             if (curr_note.hit_ms - good_window_ms) <= ms_from_start <= (curr_note.hit_ms + good_window_ms):
-                if len(self.draw_judge_list) < 7:
                 self.draw_judge_list.append(Judgment(Judgments.GOOD, big, self.is_2p))
-                self.lane_hit_effect = LaneHitEffect(drum_type, Judgments.GOOD, self.is_2p)
+                self.lane_hit_effect = LaneHitEffect(Judgments.GOOD, self.is_2p)
                 self.good_count += 1
                 self.score += self.base_score
-                if len(self.base_score_list) < 5:
                 self.base_score_list.append(ScoreCounterAnimation(self.player_num, self.base_score, self.is_2p))
                 self.input_log[curr_note.index] = 'GOOD'
                 self.note_correct(curr_note, current_time)
@@ -979,10 +963,8 @@ class Player:
 
             elif (curr_note.hit_ms - ok_window_ms) <= ms_from_start <= (curr_note.hit_ms + ok_window_ms):
                 self.draw_judge_list.append(Judgment(Judgments.OK, big, self.is_2p))
-                self.lane_hit_effect = LaneHitEffect(drum_type, Judgments.OK, self.is_2p)
                 self.ok_count += 1
                 self.score += 10 * math.floor(self.base_score / 2 / 10)
-                if len(self.base_score_list) < 5:
                 self.base_score_list.append(ScoreCounterAnimation(self.player_num, 10 * math.floor(self.base_score / 2 / 10), self.is_2p))
                 self.input_log[curr_note.index] = 'OK'
                 self.note_correct(curr_note, current_time)
@@ -1044,8 +1026,7 @@ class Player:
                 self.kusudama_anim = None
 
     def spawn_hit_effects(self, drum_type: DrumType, side: Side):
-        self.lane_hit_effect = LaneHitEffect(drum_type, Judgments.BAD, self.is_2p)  # Bad code detected...
+        self.lane_hit_effect = LaneHitEffect(drum_type, self.is_2p)
-        if len(self.draw_drum_hit_list) < 4:
         self.draw_drum_hit_list.append(DrumHitEffect(drum_type, side, self.is_2p))
 
     def handle_input(self, ms_from_start: float, current_time: float, background: Optional[Background]):
@@ -1161,7 +1142,7 @@ class Player:
         finished_arcs = []
         for i, anim in enumerate(self.draw_arc_list):
             anim.update(current_time)
-            if anim.is_finished and len(self.gauge_hit_effect) < 7:
+            if anim.is_finished:
                 self.gauge_hit_effect.append(GaugeHitEffect(anim.note_type, anim.is_big, self.is_2p))
                 finished_arcs.append(i)
         for i in reversed(finished_arcs):
@@ -1470,10 +1451,9 @@ class Judgment:
 
 class LaneHitEffect:
     """Display a gradient overlay when the player hits the drum"""
-    def __init__(self, type: DrumType, judgment: Judgments, is_2p: bool):
+    def __init__(self, type: Judgments | DrumType, is_2p: bool):
         self.is_2p = is_2p
         self.type = type
-        self.judgment = judgment
         self.fade = tex.get_animation(0, is_copy=True)
         self.fade.start()
         self.is_finished = False
@@ -1484,12 +1464,12 @@ class LaneHitEffect:
             self.is_finished = True
 
     def draw(self):
-        if self.type == DrumType.DON:
+        if self.type == Judgments.GOOD:
+            tex.draw_texture('lane', 'lane_hit_effect', frame=2, index=self.is_2p, fade=self.fade.attribute)
+        elif self.type == DrumType.DON:
             tex.draw_texture('lane', 'lane_hit_effect', frame=0, index=self.is_2p, fade=self.fade.attribute)
         elif self.type == DrumType.KAT:
             tex.draw_texture('lane', 'lane_hit_effect', frame=1, index=self.is_2p, fade=self.fade.attribute)
-        if self.judgment == Judgments.GOOD or self.judgment == Judgments.OK:
-            tex.draw_texture('lane', 'lane_hit_effect', frame=2, index=self.is_2p, fade=self.fade.attribute)
 
 class DrumHitEffect:
     """Display the side of the drum hit"""
@@ -1629,8 +1609,6 @@ class GaugeHitEffect:
 
 class NoteArc:
     """Note arcing from the player to the gauge"""
-    _arc_points_cache = {}
-
     def __init__(self, note_type: int, current_ms: float, player_num: PlayerNum, big: bool, is_balloon: bool, start_x: float = 0, start_y: float = 0):
         self.note_type = note_type
         self.is_big = big
@@ -1664,20 +1642,13 @@ class NoteArc:
         self.x_i = self.start_x
         self.y_i = self.start_y
         self.is_finished = False
-
+        self.arc_points_cache = []
-        cache_key = (self.start_x, self.start_y, self.end_x, self.end_y, self.control_x, self.control_y, self.arc_points)
-
-        if cache_key not in NoteArc._arc_points_cache:
-            arc_points_list = []
         for i in range(self.arc_points + 1):
             t = i / self.arc_points
             t_inv = 1.0 - t
             x = int(t_inv * t_inv * self.start_x + 2 * t_inv * t * self.control_x + t * t * self.end_x)
             y = int(t_inv * t_inv * self.start_y + 2 * t_inv * t * self.control_y + t * t * self.end_y)
-                arc_points_list.append((x, y))
+            self.arc_points_cache.append((x, y))
-            NoteArc._arc_points_cache[cache_key] = arc_points_list
-
-        self.arc_points_cache = NoteArc._arc_points_cache[cache_key]
 
         self.explosion_x, self.explosion_y = self.arc_points_cache[0]
         self.explosion_anim = tex.get_animation(22)

scenes/practice/game.py

@@ -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,
@@ -32,7 +32,6 @@ from scenes.game import (
     DrumType,
     GameScreen,
     JudgeCounter,
-    Judgments,
     LaneHitEffect,
     Player,
     Side,
@@ -47,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'])
+        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.parser.metadata.wave.exists() and self.parser.metadata.wave.is_file() and self.song_music is None:
+        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.parser.metadata.wave, 'song')
+            self.song_music = audio.load_music_stream(self.tja.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])
+        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.parser.notes_to_position(self.player_1.difficulty)
+        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)
@@ -99,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])
@@ -111,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
 
@@ -157,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:
@@ -312,7 +311,7 @@ class PracticePlayer(Player):
                 self.check_note(ms_from_start, drum_type, current_time, background)
 
     def spawn_hit_effects(self, drum_type: DrumType, side: Side):
-        self.lane_hit_effect = LaneHitEffect(drum_type, Judgments.BAD, self.is_2p)
+        self.lane_hit_effect = LaneHitEffect(drum_type, self.is_2p)
         self.draw_drum_hit_list.append(PracticeDrumHitEffect(drum_type, side, self.is_2p, player_num=self.player_num))
 
     def draw_overlays(self, mask_shader: ray.Shader):

scenes/settings.py

@@ -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.config import save_config
-from libs.global_objects import AllNetIcon, CoinOverlay, Indicator
 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.config = global_data.config
-        self.template = json.loads((tex.graphics_path / "settings_template.json").read_text(encoding='utf-8'))
+        self.headers = list(self.config.keys())
-        self.box_manager = BoxManager(self.template)
+        self.headers.append('Exit')
-        self.coin_overlay = CoinOverlay()
+        self.header_index = 0
-        self.allnet_indicator = AllNetIcon()
+        self.setting_index = 0
-        audio.play_sound('bgm', 'music')
+        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):
+    def get_current_settings(self):
-        if is_l_kat_pressed():
+        """Get the current section's settings as a list"""
-            audio.play_sound('kat', 'sound')
+        current_header = self.headers[self.header_index]
-            self.box_manager.move_left()
+        if current_header == 'Exit' or current_header not in self.config:
-        elif is_r_kat_pressed():
+            return []
-            audio.play_sound('kat', 'sound')
+        return list(self.config[current_header].items())
-            self.box_manager.move_right()
+
-        elif is_l_don_pressed() or is_r_don_pressed():
+    def handle_boolean_toggle(self, section, key):
-            audio.play_sound('don', 'sound')
+        """Toggle boolean values"""
-            box_name = self.box_manager.select_box()
+        self.config[section][key] = not self.config[section][key]
-            if box_name == 'exit':
+        logger.info(f"Toggled boolean setting: {section}.{key} -> {self.config[section][key]}")
-                return self.on_screen_end("ENTRY")
+
+    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()
+        # Handle key binding editing
-        self.indicator.update(current_time)
+        if self.editing_key:
-        self.box_manager.update(current_time)
+            self.update_key_binding()
-        return self.handle_input()
+            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')
+        ray.draw_rectangle(0, 0, tex.screen_width, tex.screen_height, ray.BLACK)
-        self.box_manager.draw()
+        # Draw title
-        tex.draw_texture('background', 'footer')
+        ray.draw_rectangle(0, 0, tex.screen_width, tex.screen_height, ray.BLACK)
-        self.indicator.draw(tex.skin_config['song_select_indicator'].x, tex.skin_config['song_select_indicator'].y)
+        ray.draw_text("SETTINGS", 20, 20, 30, ray.WHITE)
-        self.coin_overlay.draw()
+
-        self.allnet_indicator.draw()
+        # 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)

scenes/song_select.py

@@ -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():
+                    if song.tja.metadata.wave.exists() and song.tja.metadata.wave.is_file():
-                        self.demo_song = audio.load_music_stream(song.parser.metadata.wave, 'demo_song')
+                        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
+        elif (Difficulty.URA in selected_song.tja.metadata.course_data and
-              Difficulty.ONI not in selected_song.parser.metadata.course_data):
+              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
 

scenes/two_player/game.py

@@ -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)
+        self.tja = TJAParser(song, start_delay=self.start_delay)
-        if self.parser.metadata.bgmovie != Path() and self.parser.metadata.bgmovie.exists():
+        if self.tja.metadata.bgmovie != Path() and self.tja.metadata.bgmovie.exists():
-            self.movie = VideoPlayer(self.parser.metadata.bgmovie)
+            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'])
+        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.parser.metadata.wave.exists() and self.parser.metadata.wave.is_file() and self.song_music is None:
+        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.parser.metadata.wave, 'song')
+            self.song_music = audio.load_music_stream(self.tja.metadata.wave, 'song')
 
-        tja_copy = copy.deepcopy(self.parser)
+        tja_copy = copy.deepcopy(self.tja)
-        self.player_1 = Player(self.parser, PlayerNum.P1, global_data.session_data[PlayerNum.P1].selected_difficulty, False, global_data.modifiers[PlayerNum.P1])
+        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:

scenes/two_player/song_select.py

@@ -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()

shader/outline.fs

@@ -17,7 +17,7 @@ void main()
 
     float outline = 0.0;
     int ringSamples = 16;
-    int rings = 1;
+    int rings = 2;
     for(int ring = 1; ring <= rings; ring++) {
         float ringRadius = float(ring) / float(rings);
         for(int i = 0; i < ringSamples; i++) {

test/libs/test_texture.py

@@ -197,6 +197,33 @@ class TestTextureWrapper(unittest.TestCase):
 
         self.assertEqual(result, mock_animation)
 
+    @patch('libs.texture.get_config')
+    @patch('libs.texture.Path')
+    @patch('libs.texture.copy.deepcopy')
+    def test_get_animation_copy(self, mock_deepcopy, mock_path_cls, mock_get_config):
+        """Test getting animation copy."""
+        mock_get_config.return_value = {'paths': {'skin': 'TestSkin'}}
+
+        # Mock the skin_config.json file
+        mock_path_instance = Mock()
+        mock_config_path = Mock()
+        mock_config_path.exists.return_value = True
+        mock_config_path.read_text.return_value = '{"screen": {"width": 1280, "height": 720}}'
+        mock_path_instance.__truediv__ = Mock(return_value=mock_config_path)
+        mock_path_cls.return_value = mock_path_instance
+
+        mock_animation = Mock()
+        mock_copy = Mock()
+        mock_deepcopy.return_value = mock_copy
+
+        wrapper = TextureWrapper()
+        wrapper.animations = {0: mock_animation}
+
+        result = wrapper.get_animation(0, is_copy=True)
+
+        mock_deepcopy.assert_called_once_with(mock_animation)
+        self.assertEqual(result, mock_copy)
+
     @patch('libs.texture.get_config')
     @patch('libs.texture.Path')
     @patch('libs.texture.ray')