Add files

.gitignore

@@ -0,0 +1 @@
+Songs

entry.py

@@ -0,0 +1,16 @@
+import pyray as ray
+
+class EntryScreen:
+    def __init__(self, width, height):
+        self.width = width
+        self.height = height
+
+        self.texture_footer = ray.load_texture('Graphics\\lumendata\\entry\\entry_img00375.png')
+
+    def update(self):
+        if ray.is_key_pressed(ray.KeyboardKey.KEY_ENTER):
+            return "GAME"
+        return None
+
+    def draw(self):
+        ray.draw_texture(self.texture_footer, 0, self.height - 151, ray.WHITE)

game.py

@@ -0,0 +1,949 @@
+import os
+import pyray as ray
+import random as rand
+import math
+
+from global_funcs import *
+from collections import deque
+
+class GameScreen:
+    def __init__(self, width, height):
+        self.width = width
+        self.height = height
+        self.judge_x = 414
+
+        # Textures
+        folder_path = 'Graphics\\lumendata\\enso_system\\common\\'
+        self.texture_judge_circle = ray.load_texture(folder_path + 'lane_hit_img00017.png')
+
+        self.image_lane = ray.load_image(folder_path + 'lane_img00000.png')
+        ray.image_resize(self.image_lane, 948, 176)
+        self.texture_lane = ray.load_texture_from_image(self.image_lane)
+
+        self.texture_lane_cover = ray.load_texture(folder_path + 'lane_obi_img00000.png')
+        self.texture_score_cover = ray.load_texture(folder_path + 'lane_obi_img00003.png')
+
+        self.texture_don = [ray.load_texture(folder_path + 'onp_don_img00000.png'),
+                            ray.load_texture(folder_path + 'onp_don_img00001.png')]
+        self.texture_kat = [ray.load_texture(folder_path + 'onp_katsu_img00000.png'),
+                            ray.load_texture(folder_path + 'onp_katsu_img00001.png')]
+
+        self.texture_dai_don = [ray.load_texture(folder_path + 'onp_don_dai_img00000.png'),
+                                ray.load_texture(folder_path + 'onp_don_dai_img00001.png')]
+        self.texture_dai_kat = [ray.load_texture(folder_path + 'onp_katsu_dai_img00000.png'),
+                                ray.load_texture(folder_path + 'onp_katsu_dai_img00001.png')]
+
+        self.texture_balloon_head = [ray.load_texture(folder_path + 'onp_fusen_img00001.png'),
+                                     ray.load_texture(folder_path + 'onp_fusen_img00002.png')]
+        self.texture_balloon_tail = [ray.load_texture(folder_path + 'onp_fusen_img00000.png'),
+                                     ray.load_texture(folder_path + 'onp_fusen_img00000.png')]
+
+        self.texture_drumroll_head = [ray.load_texture(folder_path + 'onp_renda_img00002.png'),
+                                      ray.load_texture(folder_path + 'onp_renda_img00003.png')]
+        self.texture_drumroll_body = [ray.load_texture(folder_path + 'onp_renda_img00000.png'),
+                                      ray.load_texture(folder_path + 'onp_renda_img00000.png')]
+        self.texture_drumroll_tail = [ray.load_texture(folder_path + 'onp_renda_img00001.png'),
+                                      ray.load_texture(folder_path + 'onp_renda_img00001.png')]
+        self.texture_dai_drumroll_head = [ray.load_texture(folder_path + 'onp_renda_dai_img00002.png'),
+                                          ray.load_texture(folder_path + 'onp_renda_dai_img00003.png')]
+        self.texture_dai_drumroll_body = [ray.load_texture(folder_path + 'onp_renda_dai_img00000.png'),
+                                          ray.load_texture(folder_path + 'onp_renda_dai_img00000.png')]
+        self.texture_dai_drumroll_tail = [ray.load_texture(folder_path + 'onp_renda_dai_img00001.png'),
+                                          ray.load_texture(folder_path + 'onp_renda_dai_img00001.png')]
+        self.texture_drumroll_count = ray.load_texture(folder_path + 'renda_num_img00000.png')
+        self.texture_drumroll_number = [ray.load_texture(folder_path + 'renda_num_img00001.png'),
+                                        ray.load_texture(folder_path + 'renda_num_img00002.png'),
+                                        ray.load_texture(folder_path + 'renda_num_img00003.png'),
+                                        ray.load_texture(folder_path + 'renda_num_img00004.png'),
+                                        ray.load_texture(folder_path + 'renda_num_img00005.png'),
+                                        ray.load_texture(folder_path + 'renda_num_img00006.png'),
+                                        ray.load_texture(folder_path + 'renda_num_img00007.png'),
+                                        ray.load_texture(folder_path + 'renda_num_img00008.png'),
+                                        ray.load_texture(folder_path + 'renda_num_img00009.png'),
+                                        ray.load_texture(folder_path + 'renda_num_img00010.png')]
+
+
+        self.texture_barline = ray.load_texture(folder_path + 'lane_syousetsu_img00000.png')
+
+        self.texture_good = ray.load_texture(folder_path + 'lane_hit_effect_img00009.png')
+        self.texture_good_hit_center = ray.load_texture(folder_path + 'lane_hit_img00019.png')
+        self.texture_good_hit_center_big = ray.load_texture(folder_path + 'lane_hit_img00021.png')
+        self.texture_good_hit_effect = [ray.load_texture(folder_path + 'lane_hit_effect_img00005.png'),
+                                        ray.load_texture(folder_path + 'lane_hit_effect_img00006.png'),
+                                        ray.load_texture(folder_path + 'lane_hit_effect_img00007.png'),
+                                        ray.load_texture(folder_path + 'lane_hit_effect_img00008.png'),
+                                        ray.load_texture(folder_path + 'lane_hit_effect_img00008.png')]
+        self.texture_good_hit_effect_big = [ray.load_texture(folder_path + 'lane_hit_effect_img00011.png'),
+                                        ray.load_texture(folder_path + 'lane_hit_effect_img00012.png'),
+                                        ray.load_texture(folder_path + 'lane_hit_effect_img00013.png'),
+                                        ray.load_texture(folder_path + 'lane_hit_effect_img00014.png'),
+                                        ray.load_texture(folder_path + 'lane_hit_effect_img00015.png')]
+
+        self.texture_ok = ray.load_texture(folder_path + 'lane_hit_effect_img00004.png')
+        self.texture_ok_hit_center = ray.load_texture(folder_path + 'lane_hit_img00018.png')
+        self.texture_ok_hit_center_big = ray.load_texture(folder_path + 'lane_hit_img00020.png')
+        self.texture_ok_hit_effect = [ray.load_texture(folder_path + 'lane_hit_effect_img00000.png'),
+                                        ray.load_texture(folder_path + 'lane_hit_effect_img00001.png'),
+                                        ray.load_texture(folder_path + 'lane_hit_effect_img00002.png'),
+                                        ray.load_texture(folder_path + 'lane_hit_effect_img00003.png'),
+                                        ray.load_texture(folder_path + 'lane_hit_effect_img00003.png')]
+        self.texture_ok_hit_effect_big = [ray.load_texture(folder_path + 'lane_hit_effect_img00016.png'),
+                                        ray.load_texture(folder_path + 'lane_hit_effect_img00017.png'),
+                                        ray.load_texture(folder_path + 'lane_hit_effect_img00018.png'),
+                                        ray.load_texture(folder_path + 'lane_hit_effect_img00019.png'),
+                                        ray.load_texture(folder_path + 'lane_hit_effect_img00020.png')]
+
+        self.texture_bad = ray.load_texture(folder_path + 'lane_hit_effect_img00010.png')
+
+        self.image_lane_effect_good = ray.load_image(folder_path + 'lane_hit_img00007.png')
+        ray.image_resize(self.image_lane_effect_good, 951, 130)
+        self.image_lane_effect_don = ray.load_image(folder_path + 'lane_hit_img00005.png')
+        ray.image_resize(self.image_lane_effect_don, 951, 130)
+        self.image_lane_effect_kat = ray.load_image(folder_path + 'lane_hit_img00006.png')
+        ray.image_resize(self.image_lane_effect_kat, 951, 130)
+        self.texture_lane_effect_good = ray.load_texture_from_image(self.image_lane_effect_good)
+        self.texture_lane_effect_don = ray.load_texture_from_image(self.image_lane_effect_don)
+        self.texture_lane_effect_kat = ray.load_texture_from_image(self.image_lane_effect_kat)
+
+        self.texture_drum = ray.load_texture(folder_path + 'lane_obi_img00014.png')
+        self.texture_don_R = ray.load_texture(folder_path + 'lane_obi_img00015.png')
+        self.texture_don_L = ray.load_texture(folder_path + 'lane_obi_img00016.png')
+        self.texture_kat_R = ray.load_texture(folder_path + 'lane_obi_img00017.png')
+        self.texture_kat_L = ray.load_texture(folder_path + 'lane_obi_img00018.png')
+
+        self.texture_1p_emblem = ray.load_texture(folder_path + 'lane_obi_img00019.png')
+        self.texture_difficulty = [ray.load_texture(folder_path + 'lane_obi_img00021.png'),
+                                   ray.load_texture(folder_path + 'lane_obi_img00022.png'),
+                                   ray.load_texture(folder_path + 'lane_obi_img00023.png'),
+                                   ray.load_texture(folder_path + 'lane_obi_img00024.png'),
+                                   ray.load_texture(folder_path + 'lane_obi_img00025.png')]
+
+        self.texture_combo_text = [ray.load_texture(folder_path + 'lane_obi_img00035.png'),
+                                   ray.load_texture(folder_path + 'lane_obi_img00046.png')]
+        self.texture_combo_numbers = [ray.load_texture(folder_path + 'lane_obi_img00036.png'),
+                                      ray.load_texture(folder_path + 'lane_obi_img00037.png'),
+                                      ray.load_texture(folder_path + 'lane_obi_img00038.png'),
+                                      ray.load_texture(folder_path + 'lane_obi_img00039.png'),
+                                      ray.load_texture(folder_path + 'lane_obi_img00040.png'),
+                                      ray.load_texture(folder_path + 'lane_obi_img00041.png'),
+                                      ray.load_texture(folder_path + 'lane_obi_img00042.png'),
+                                      ray.load_texture(folder_path + 'lane_obi_img00043.png'),
+                                      ray.load_texture(folder_path + 'lane_obi_img00044.png'),
+                                      ray.load_texture(folder_path + 'lane_obi_img00045.png'),
+                                      ray.load_texture(folder_path + 'lane_obi_img00047.png'),
+                                      ray.load_texture(folder_path + 'lane_obi_img00049.png'),
+                                      ray.load_texture(folder_path + 'lane_obi_img00050.png'),
+                                      ray.load_texture(folder_path + 'lane_obi_img00051.png'),
+                                      ray.load_texture(folder_path + 'lane_obi_img00052.png'),
+                                      ray.load_texture(folder_path + 'lane_obi_img00053.png'),
+                                      ray.load_texture(folder_path + 'lane_obi_img00054.png'),
+                                      ray.load_texture(folder_path + 'lane_obi_img00055.png'),
+                                      ray.load_texture(folder_path + 'lane_obi_img00056.png'),
+                                      ray.load_texture(folder_path + 'lane_obi_img00057.png')]
+        self.texture_combo_glimmer = ray.load_texture(folder_path + 'lane_obi_img00048.png')
+
+        folder_path = 'Graphics\\lumendata\\enso_system\\base1p\\'
+        self.texture_balloon_speech_bubble_p1 = ray.load_texture(folder_path + 'action_fusen_1p_img00000.png')
+        self.texture_balloon = [ray.load_texture(folder_path + 'action_fusen_1p_img00011.png'),
+                                ray.load_texture(folder_path + 'action_fusen_1p_img00012.png'),
+                                ray.load_texture(folder_path + 'action_fusen_1p_img00013.png'),
+                                ray.load_texture(folder_path + 'action_fusen_1p_img00014.png'),
+                                ray.load_texture(folder_path + 'action_fusen_1p_img00015.png'),
+                                ray.load_texture(folder_path + 'action_fusen_1p_img00016.png'),
+                                ray.load_texture(folder_path + 'action_fusen_1p_img00017.png'),
+                                ray.load_texture(folder_path + 'action_fusen_1p_img00018.png')]
+        self.texture_balloon_number = [ray.load_texture(folder_path + 'action_fusen_1p_img00001.png'),
+                                       ray.load_texture(folder_path + 'action_fusen_1p_img00002.png'),
+                                       ray.load_texture(folder_path + 'action_fusen_1p_img00003.png'),
+                                       ray.load_texture(folder_path + 'action_fusen_1p_img00004.png'),
+                                       ray.load_texture(folder_path + 'action_fusen_1p_img00005.png'),
+                                       ray.load_texture(folder_path + 'action_fusen_1p_img00006.png'),
+                                       ray.load_texture(folder_path + 'action_fusen_1p_img00007.png'),
+                                       ray.load_texture(folder_path + 'action_fusen_1p_img00008.png'),
+                                       ray.load_texture(folder_path + 'action_fusen_1p_img00009.png'),
+                                       ray.load_texture(folder_path + 'action_fusen_1p_img00010.png')]
+
+        self.current_ms = 0
+
+        self.sound_don = ray.load_sound('Sounds\\inst_00_don.wav')
+        self.sound_kat = ray.load_sound('Sounds\\inst_00_katsu.wav')
+        self.sound_balloon_pop = ray.load_sound('Sounds\\balloon_pop.wav')
+
+        self.note_type_dict = {'1': self.texture_don,
+                               '2': self.texture_kat,
+                               '3': self.texture_dai_don,
+                               '4': self.texture_dai_kat,
+                               '5': self.texture_drumroll_head,
+                               '6': self.texture_dai_drumroll_head,
+                               '7': self.texture_balloon_head,
+                               'drumroll_body': self.texture_drumroll_body,
+                               'drumroll_tail': self.texture_drumroll_tail,
+                               'dai_drumroll_body': self.texture_dai_drumroll_body,
+                               'dai_drumroll_tail': self.texture_dai_drumroll_tail,
+                               'balloon_tail': self.texture_balloon_tail}
+
+    def init_tja(self):
+        self.tja = tja_parser('Songs\\Dokidoki Mune-kyun Omatsuri Time')
+        self.tja.get_metadata()
+        self.tja.distance = self.width - self.judge_x
+
+        self.player_1 = Player(self, 1, 3)
+        self.song_music = ray.load_music_stream(self.tja.wave)
+        ray.play_music_stream(self.song_music)
+        self.start_ms = get_current_ms() - self.tja.offset*1000
+
+    def update(self):
+        ray.update_music_stream(self.song_music)
+        self.current_ms = get_current_ms() - self.start_ms
+        self.player_1.update(self)
+
+    def draw(self):
+        self.player_1.draw(self)
+
+class Player:
+    def __init__(self, game_screen, player_number, difficulty):
+        self.timing_good = 25.0250015258789
+        self.timing_ok = 75.0750045776367
+        self.timing_bad = 108.441665649414
+
+        self.player_number = player_number
+        self.difficulty = difficulty
+
+        self.play_note_list, self.draw_note_list, self.draw_bar_list = game_screen.tja.notes_to_position(self.difficulty)
+        self.base_score = self.calculate_base_score()
+
+        self.judge_offset = 0
+
+        #Note management
+        self.current_notes = deque()
+        self.current_bars = []
+        self.current_notes_draw = []
+        self.play_note_index = 0
+        self.draw_note_index = 0
+        self.bar_index = 0
+        self.is_drumroll = False
+        self.drumroll_big = 0
+        self.curr_drumroll_count = 0
+        self.is_balloon = False
+        self.curr_balloon_count = 0
+
+        #Score management
+        self.good_count = 0
+        self.ok_count = 0
+        self.bad_count = 0
+        self.combo = 0
+        self.score = 0
+        self.max_combo = 0
+
+        self.arc_points = 25
+
+        self.draw_judge_list = []
+        self.draw_effect_list = []
+        self.draw_arc_list = []
+        self.draw_drum_hit_list = []
+        self.drumroll_counter = []
+        self.balloon_list = []
+        self.combo_list = []
+
+    def calculate_base_score(self):
+        total_notes = 0
+        balloon_num = 0
+        balloon_sec = 0
+        balloon_count = 0
+        drumroll_sec = 0
+        for i in range(len(self.play_note_list)):
+            note = self.play_note_list[i]
+            if i < len(self.play_note_list)-1:
+                next_note = self.play_note_list[i+1]
+            else:
+                next_note = self.play_note_list[len(self.play_note_list)-1]
+            if note.get('note') in {'1','2','3','4'}:
+                total_notes += 1
+            elif note.get('note') in {'5', '6'}:
+                drumroll_sec += (next_note.get('ms') - note.get('ms')) / 1000
+            elif note.get('note') in {'7', '9'}:
+                balloon_num += 1
+                balloon_count += next_note.get('balloon')
+        total_score = (1000000 - (balloon_count * 100) - (drumroll_sec * 1692.0079999994086)) / total_notes
+        return math.ceil(total_score / 10) * 10
+
+    def get_position(self, game_screen, ms, pixels_per_frame):
+        return int(game_screen.width + pixels_per_frame * 60 / 1000 * (ms - game_screen.current_ms + self.judge_offset) - 64)
+
+    def animation_manager(self, game_screen, animation_list):
+        if len(animation_list) != 0:
+            for i in range(len(animation_list)-1, -1, -1):
+                animation = animation_list[i]
+                animation.update(game_screen.current_ms)
+                if animation.is_finished:
+                    animation_list.pop(i)
+
+    def note_manager(self, game_screen):
+        #Add bar to current_bars list if it is ready to be shown on screen
+        if game_screen.current_ms > self.draw_bar_list[0]['load_ms'] and len(self.draw_bar_list) > 0:
+            self.current_bars.append(self.draw_bar_list.popleft())
+
+        #Add note to current_notes list if it is ready to be shown on screen
+        if game_screen.current_ms + 1000 >= self.play_note_list[0]['load_ms']:
+            self.current_notes.append(self.play_note_list.popleft())
+            if self.play_note_list[0]['note'] == '8':
+                self.current_notes.append(self.play_note_list.popleft())
+        if game_screen.current_ms + 1000 >= self.draw_note_list[0]['load_ms']:
+            self.current_notes_draw.append(self.draw_note_list.popleft())
+            if self.draw_note_list[0]['note'] == '8':
+                self.current_notes_draw.append(self.draw_note_list.popleft())
+
+        #if a note was not hit within the window, remove it
+        if len(self.current_notes) != 0:
+            note = self.current_notes[0]
+            if note['ms'] + self.timing_bad < game_screen.current_ms:
+                if note['note'] in {'1', '2', '3', '4'}:
+                    self.combo = 0
+                    self.bad_count += 1
+                self.current_notes.popleft()
+            elif (note['ms'] <= game_screen.current_ms):
+                if note['note'] == '5':
+                    self.is_drumroll = True
+                    self.drumroll_big = 0
+                elif note['note'] == '6':
+                    self.is_drumroll = True
+                    self.drumroll_big = 2
+                elif note['note'] == '7':
+                    self.is_balloon = True
+                elif note['note'] == '8' and (self.is_drumroll or self.is_balloon):
+                    self.is_drumroll = False
+                    self.is_balloon = False
+        #If a bar is off screen, remove it
+        if len(self.current_bars) != 0:
+            for i in range(len(self.current_bars)-1, -1, -1):
+                bar_ms, pixels_per_frame = self.current_bars[i]['ms'], self.current_bars[i]['ppf']
+                position = self.get_position(game_screen, bar_ms, pixels_per_frame)
+                if position < game_screen.judge_x + 650:
+                    self.current_bars.pop(i)
+
+        #If a note is off screen, remove it
+        if len(self.current_notes_draw) != 0:
+            for i in range(len(self.current_notes_draw)-1, -1, -1):
+                note_type, note_ms, pixels_per_frame = self.current_notes_draw[i]['note'], self.current_notes_draw[i]['ms'], self.current_notes_draw[i]['ppf']
+                position = self.get_position(game_screen, note_ms, pixels_per_frame)
+                if position < game_screen.judge_x + 650 and note_type not in {'5', '6', '7'}:
+                    if note_type == '8' and self.current_notes_draw[i-1]['note'] in {'5', '6', '7'} and self.current_notes_draw[i-1]['ms'] < self.current_notes_draw[i]['ms']:
+                        self.current_notes_draw.pop(i-1)
+                    else:
+                        self.current_notes_draw.pop(i)
+
+        if len(self.current_notes_draw) != 0:
+            if self.current_notes_draw[0]['note'] in {'5', '6', '8'}:
+                if 255 > self.current_notes_draw[0]['color'] > 0:
+                    self.current_notes_draw[0]['color'] += 1
+
+    def note_correct(self, game_screen, note):
+        index = note['index']
+        if note['note'] == '8':
+            note_type = game_screen.note_type_dict['3']
+        else:
+            note_type = game_screen.note_type_dict[note['note']]
+
+        self.combo += 1
+        if self.combo > self.max_combo:
+            self.max_combo = self.combo
+
+        self.draw_arc_list.append(NoteArc(note_type, game_screen.current_ms, self.player_number))
+        self.current_notes.popleft()
+
+        #Remove note from the screen
+        if note in self.current_notes_draw:
+            i = self.current_notes_draw.index(note)
+            if note['note'] == '8' and self.current_notes_draw[i-1]['note'] == '7' and self.current_notes_draw[i-1]['ms'] < self.current_notes_draw[i]['ms']:
+                self.current_notes_draw.pop(i-1)
+                self.current_notes_draw.pop(i-1)
+            else:
+                self.current_notes_draw.pop(i)
+
+    def check_note(self, game_screen, drum_type):
+        if self.is_drumroll:
+            note_type = game_screen.note_type_dict[str(int(drum_type)+self.drumroll_big)]
+            self.draw_arc_list.append(NoteArc(note_type, game_screen.current_ms, self.player_number))
+            self.curr_drumroll_count += 1
+            color = 255 - (self.curr_drumroll_count*10)
+            if color < 0:
+                self.current_notes_draw[0]['color'] = 0
+            else:
+                self.current_notes_draw[0]['color'] = color
+        elif self.is_balloon and drum_type == '1':
+            current_note = self.current_notes[0]
+            if current_note['note'] == '7':
+                current_note = self.current_notes[1]
+            if len(self.balloon_list) < 1:
+                self.balloon_list.append(BalloonAnimation(game_screen.current_ms, current_note['balloon']))
+            self.curr_balloon_count += 1
+            self.current_notes_draw[0]['popped'] = False
+            if self.curr_balloon_count == current_note['balloon']:
+                self.is_balloon = False
+                self.current_notes_draw[0]['popped'] = True
+                ray.play_sound(game_screen.sound_balloon_pop)
+                self.note_correct(game_screen, self.current_notes[0])
+        elif len(self.current_notes) != 0:
+            self.curr_drumroll_count = 0
+            self.curr_balloon_count = 0
+            current_note = self.current_notes[0]
+            note_type = current_note['note']
+            note_ms = current_note['ms']
+            #If the wrong key was hit, stop checking
+            if drum_type == '1' and note_type not in {'1', '3'}:
+                return
+            if drum_type == '2' and note_type not in {'2', '4'}:
+                return
+            #If the note is too far away, stop checking
+            if game_screen.current_ms > (note_ms + self.timing_bad):
+                return
+            if note_type in ('3','4'):
+                big = True
+            else:
+                big = False
+            if (note_ms - self.timing_good) + self.judge_offset <= game_screen.current_ms <= (note_ms + self.timing_good) + self.judge_offset:
+                self.draw_judge_list.append(Judgement(game_screen.current_ms, 'GOOD', big))
+                self.draw_effect_list.pop()
+                self.draw_effect_list.append(LaneHitEffect(game_screen.current_ms, 'GOOD'))
+                self.good_count += 1
+                self.score += self.base_score
+                self.note_correct(game_screen, current_note)
+
+            elif (note_ms - self.timing_ok) + self.judge_offset <= game_screen.current_ms <= (note_ms + self.timing_ok) + self.judge_offset:
+                self.draw_judge_list.append(Judgement(game_screen.current_ms, 'OK', big))
+                self.ok_count += 1
+                self.score += 10 * math.floor(self.base_score / 2 / 10)
+                self.note_correct(game_screen, current_note)
+
+            elif (note_ms - self.timing_bad) + self.judge_offset <= game_screen.current_ms <= (note_ms + self.timing_bad) + self.judge_offset:
+                self.draw_judge_list.append(Judgement(game_screen.current_ms, 'BAD', big))
+                self.bad_count += 1
+                self.combo = 0
+
+    def drumroll_counter_manager(self, game_screen):
+        if self.is_drumroll and self.curr_drumroll_count > 0:
+            if len(self.drumroll_counter) == 0 or self.drumroll_counter[-1].is_finished:
+                self.drumroll_counter.append(DrumrollCounter(game_screen.current_ms))
+
+        if len(self.drumroll_counter) > 0:
+            if self.drumroll_counter[0].is_finished:
+                self.drumroll_counter.pop(0)
+            else:
+                self.drumroll_counter[0].update(game_screen, game_screen.current_ms, self.curr_drumroll_count)
+
+    def balloon_animation_manager(self, game_screen):
+        if len(self.balloon_list) != 0:
+            if self.balloon_list[0].is_finished:
+                self.balloon_list.pop(0)
+            else:
+                if self.is_balloon:
+                    self.balloon_list[0].update(game_screen, game_screen.current_ms, self.curr_balloon_count, False)
+                else:
+                    self.balloon_list[0].update(game_screen, game_screen.current_ms, self.curr_balloon_count, True)
+
+    def combo_manager(self, game_screen):
+        if self.combo >= 3 and len(self.combo_list) == 0:
+            self.combo_list.append(Combo(self.combo, game_screen.current_ms))
+        elif self.combo < 3 and len(self.combo_list) != 0:
+            self.combo_list.pop(0)
+        elif len(self.combo_list) == 1:
+            self.combo_list[0].update(game_screen, game_screen.current_ms, self.combo)
+
+    def key_manager(self, game_screen):
+        if ray.is_key_pressed(ray.KeyboardKey.KEY_F):
+            self.draw_effect_list.append(LaneHitEffect(game_screen.current_ms, 'DON'))
+            self.draw_drum_hit_list.append(DrumHitEffect(game_screen.current_ms, 'DON', 'L'))
+            ray.play_sound(game_screen.sound_don)
+            self.check_note(game_screen, '1')
+        if ray.is_key_pressed(ray.KeyboardKey.KEY_J):
+            self.draw_effect_list.append(LaneHitEffect(game_screen.current_ms, 'DON'))
+            self.draw_drum_hit_list.append(DrumHitEffect(game_screen.current_ms, 'DON', 'R'))
+            ray.play_sound(game_screen.sound_don)
+            self.check_note(game_screen, '1')
+        if ray.is_key_pressed(ray.KeyboardKey.KEY_E):
+            self.draw_effect_list.append(LaneHitEffect(game_screen.current_ms, 'KAT'))
+            self.draw_drum_hit_list.append(DrumHitEffect(game_screen.current_ms, 'KAT', 'L'))
+            ray.play_sound(game_screen.sound_kat)
+            self.check_note(game_screen, '2')
+        if ray.is_key_pressed(ray.KeyboardKey.KEY_I):
+            self.draw_effect_list.append(LaneHitEffect(game_screen.current_ms, 'KAT'))
+            self.draw_drum_hit_list.append(DrumHitEffect(game_screen.current_ms, 'KAT', 'R'))
+            ray.play_sound(game_screen.sound_kat)
+            self.check_note(game_screen, '2')
+
+    def update(self, game_screen):
+        self.current_notes_draw = sorted(self.current_notes_draw, key=lambda d: d['ms'])
+        self.note_manager(game_screen)
+        self.combo_manager(game_screen)
+        self.drumroll_counter_manager(game_screen)
+        self.balloon_animation_manager(game_screen)
+        self.animation_manager(game_screen, self.draw_judge_list)
+        self.animation_manager(game_screen, self.draw_effect_list)
+        self.animation_manager(game_screen, self.draw_drum_hit_list)
+        self.animation_manager(game_screen, self.draw_arc_list)
+        self.key_manager(game_screen)
+
+    def draw_animation_list(self, game_screen, animation_list):
+        for animation in animation_list:
+            animation.draw(game_screen)
+
+    def draw_drumroll(self, game_screen, big, position, index, color):
+        drumroll_start_position = position
+        tail = self.current_notes_draw[index+1]
+        if big:
+            drumroll_body = 'dai_drumroll_body'
+            drumroll_tail = 'dai_drumroll_tail'
+            drumroll_length = 70
+        else:
+            drumroll_body = 'drumroll_body'
+            drumroll_tail = 'drumroll_tail'
+            drumroll_length = 47
+        if tail['note'] == '8':
+            drumroll_end_position = self.get_position(game_screen, tail['load_ms'], tail['ppf'])
+            distance = ((drumroll_end_position - drumroll_start_position) / drumroll_length) - 1
+            if distance > 0:
+                for i in range(int(distance)):
+                    self.draw_note(game_screen, drumroll_body, (drumroll_start_position + 64) + (i*drumroll_length), color)
+                self.draw_note(game_screen, drumroll_body, drumroll_end_position - drumroll_length, color)
+                self.draw_note(game_screen, drumroll_tail, drumroll_end_position, color)
+                drumroll_end_position = 0
+
+    def draw_balloon(self, game_screen, note, position, index):
+        end_time = self.current_notes_draw[index+1]
+        end_time_position = self.get_position(game_screen, end_time['load_ms'], end_time['ppf'])
+        if game_screen.current_ms >= end_time['ms']:
+            position = end_time_position
+        elif game_screen.current_ms >= note['ms']:
+            position = 349
+        self.draw_note(game_screen, '7', position, 255)
+
+    def draw_note(self, game_screen, note, position, color):
+        note_padding = 64
+        if note == 'barline':
+            y = 184
+            ray.draw_texture(game_screen.texture_barline, position+note_padding-4, y+6, ray.WHITE)
+        elif note in game_screen.note_type_dict:
+            eighth_in_ms = (60000 * 4 / game_screen.tja.bpm) / 8
+            if self.combo >= 50:
+                current_eighth = int(game_screen.current_ms // eighth_in_ms)
+            else:
+                current_eighth = 0
+            if note in {'5', '6', 'drumroll_tail', 'dai_drumroll_tail', 'drumroll_body', 'dai_drumroll_body'}:
+                draw_color = color
+            else:
+                draw_color = 255
+            if note == '7':
+                offset = 12
+                balloon = True
+            else:
+                offset = 0
+                balloon = False
+            ray.draw_texture(game_screen.note_type_dict[note][current_eighth % 2], position-offset, 192, ray.Color(255, draw_color, draw_color, 255))
+            if balloon:
+                ray.draw_texture(game_screen.note_type_dict['balloon_tail'][current_eighth % 2], position-offset+128, 192, ray.Color(255, draw_color, draw_color, 255))
+
+    def draw_notes(self, game_screen):
+        if len(self.current_notes_draw) != 0 or len(self.current_bars) != 0:
+            for i in range(len(self.current_bars)-1, -1, -1):
+                bar = self.current_bars[i]
+                load_ms, pixels_per_frame = bar['load_ms'], bar['ppf']
+                position = self.get_position(game_screen, load_ms, pixels_per_frame)
+                self.draw_note(game_screen, 'barline', position, 255)
+
+            for i in range(len(self.current_notes_draw)-1, -1, -1):
+                note = self.current_notes_draw[i]
+                note_type, load_ms, pixels_per_frame = note['note'], note['load_ms'], note['ppf']
+                position = self.get_position(game_screen, load_ms, pixels_per_frame)
+                if 'popped' in note:
+                    continue
+                if note_type == '5':
+                    self.draw_drumroll(game_screen, False, position, i, note['color'])
+                elif note_type == '6':
+                    self.draw_drumroll(game_screen, True, position, i, note['color'])
+                if note_type == '7':
+                    self.draw_balloon(game_screen, note, position, i)
+                else:
+                    self.draw_note(game_screen, note_type, position, 255)
+
+    def draw(self, game_screen):
+        ray.draw_texture(game_screen.texture_lane, 332, 184, ray.WHITE)
+        self.draw_animation_list(game_screen, self.draw_effect_list)
+        ray.draw_texture(game_screen.texture_judge_circle, 342, 184, ray.WHITE)
+        self.draw_animation_list(game_screen, self.draw_judge_list)
+        self.draw_notes(game_screen)
+        ray.draw_texture(game_screen.texture_lane_cover, 0, 184, ray.WHITE)
+        ray.draw_texture(game_screen.texture_drum, 211, 206, ray.WHITE)
+        self.draw_animation_list(game_screen, self.draw_drum_hit_list)
+        self.draw_animation_list(game_screen, self.combo_list)
+        ray.draw_texture(game_screen.texture_score_cover, 0, 184, ray.WHITE)
+        ray.draw_texture(game_screen.texture_1p_emblem, 0, 225, ray.WHITE)
+        ray.draw_texture(game_screen.texture_difficulty[self.difficulty], 50, 222, ray.WHITE)
+        self.draw_animation_list(game_screen, self.drumroll_counter)
+        self.draw_animation_list(game_screen, self.draw_arc_list)
+        self.draw_animation_list(game_screen, self.balloon_list)
+
+class Judgement:
+    def __init__(self, current_ms, type, big):
+        self.y_pos = 144
+        self.create_ms = current_ms
+        self.total_distance = 15
+        self.current_y_pos = self.y_pos
+        self.total_duration = 332
+        self.type = type
+        self.fade = 1
+        self.hit_fade = 0.5
+        self.color = ray.fade(ray.WHITE, self.fade)
+        self.hit_color = ray.fade(ray.WHITE, self.hit_fade)
+        self.big = big
+        self.index = 0
+        self.is_finished = False
+
+    def update(self, current_ms):
+        elapsed_time = current_ms - self.create_ms
+
+        if elapsed_time <= self.total_duration:
+            if elapsed_time <= 83:
+                progress = elapsed_time / 83
+                self.current_y_pos = self.y_pos + (self.total_distance * progress)
+            else:
+                self.current_y_pos = self.y_pos + self.total_distance
+
+            if 33 < elapsed_time <= 50:
+                self.index = 1
+            elif 50 < elapsed_time <= 83:
+                self.index = 2
+            elif 83 < elapsed_time <= 100:
+                self.index = 3
+            elif elapsed_time > 100:
+                self.index = 4
+            elif 83 < elapsed_time <= 166:
+                hit_fade_progress = (elapsed_time - 83) / (166 - 83)
+                self.hit_fade = 1 - hit_fade_progress
+                self.hit_color = ray.fade(ray.WHITE, self.fade)
+            if elapsed_time > 233.3:
+                fade_progress = (elapsed_time - 233.3) / (333 - 233.3)
+                self.fade = 1 - fade_progress
+                self.color = ray.fade(ray.WHITE, self.fade)
+        if elapsed_time > self.total_duration:
+            self.is_finished = True
+
+    def draw(self, game_screen):
+        if self.type == 'GOOD':
+            if self.big:
+                ray.draw_texture(game_screen.texture_good_hit_center_big, 342, 184, self.color)
+                ray.draw_texture(game_screen.texture_good_hit_effect_big[self.index], 304, 143, self.hit_color)
+            else:
+                ray.draw_texture(game_screen.texture_good_hit_center, 342, 184, self.color)
+                ray.draw_texture(game_screen.texture_good_hit_effect[self.index], 304, 143, self.hit_color)
+            ray.draw_texture(game_screen.texture_good, 370, int(self.current_y_pos), self.color)
+        elif self.type == 'OK':
+            if self.big:
+                ray.draw_texture(game_screen.texture_ok_hit_center_big, 342, 184, self.color)
+                ray.draw_texture(game_screen.texture_ok_hit_effect_big[self.index], 304, 143, self.hit_color)
+            else:
+                ray.draw_texture(game_screen.texture_ok_hit_center, 342, 184, self.color)
+                ray.draw_texture(game_screen.texture_ok_hit_effect[self.index], 304, 143, self.hit_color)
+            ray.draw_texture(game_screen.texture_ok, 370, int(self.current_y_pos), self.color)
+        elif self.type == 'BAD':
+            ray.draw_texture(game_screen.texture_bad, 370, int(self.current_y_pos), self.color)
+
+class LaneHitEffect:
+    def __init__(self, current_ms, type):
+        self.type = type
+        self.fade = 0.5
+        self.color = ray.fade(ray.WHITE, self.fade)
+        self.create_ms = current_ms
+        self.total_duration = 150
+        self.is_finished = False
+    def update(self, current_ms):
+        elapsed_time = current_ms - self.create_ms
+        if elapsed_time >= 83:
+            fade_progress = (elapsed_time - 83) / (self.total_duration - 83)
+            self.fade = 0.5 - fade_progress
+            self.color = ray.fade(ray.WHITE, self.fade)
+        if elapsed_time > self.total_duration:
+            self.is_finished = True
+
+    def draw(self, game_screen):
+        if self.type == 'GOOD':
+            ray.draw_texture(game_screen.texture_lane_effect_good, 328, 192, self.color)
+        elif self.type == 'DON':
+            ray.draw_texture(game_screen.texture_lane_effect_don, 328, 192, self.color)
+        elif self.type == 'KAT':
+            ray.draw_texture(game_screen.texture_lane_effect_kat, 328, 192, self.color)
+
+class DrumHitEffect:
+    def __init__(self, current_ms, type, side):
+        self.type = type
+        self.side = side
+        self.fade = 1
+        self.color = ray.fade(ray.WHITE, self.fade)
+        self.create_ms = current_ms
+        self.total_duration = 150
+        self.is_finished = False
+
+    def update(self, current_ms):
+        elapsed_time = current_ms - self.create_ms
+        if elapsed_time >= 83:
+            fade_progress = (elapsed_time - 83) / (self.total_duration - 83)
+            self.fade = 0.5 - fade_progress
+            self.color = ray.fade(ray.WHITE, self.fade)
+        if elapsed_time > self.total_duration:
+            self.is_finished = True
+
+    def draw(self, game_screen):
+        x, y = 211, 206
+        if self.type == 'DON':
+            if self.side == 'L':
+                ray.draw_texture(game_screen.texture_don_L, x, y, self.color)
+            elif self.side == 'R':
+                ray.draw_texture(game_screen.texture_don_R, x, y, self.color)
+        elif self.type == 'KAT':
+            if self.side == 'L':
+                ray.draw_texture(game_screen.texture_kat_L, x, y, self.color)
+            elif self.side == 'R':
+                ray.draw_texture(game_screen.texture_kat_R, x, y, self.color)
+
+class NoteArc:
+    def __init__(self, note_type, current_ms, player_number):
+        self.note_type = note_type
+        self.arc_points = 25
+        self.create_ms = current_ms
+        self.player_number = player_number
+        self.x_i = 0
+        self.y_i = 0
+        self.is_finished = False
+
+    def update(self, game_screen):
+        if self.x_i >= 1150:
+            self.is_finished = True
+    def draw(self, game_screen):
+        if self.note_type == None:
+            return
+        radius = 414
+        #Start at 180 degrees, end at 0
+        theta_start = 3.14
+        if self.player_number == 1:
+            theta_end = 2 * 3.14
+            #center of circle that does not exist
+            center_x, center_y = 785, 168
+        else:
+            theta_end = 0
+            center_x, center_y = 785, 468
+
+        ms_since_call = (game_screen.current_ms - self.create_ms) / 16.67
+        if ms_since_call < 0:
+            ms_since_call = 0
+        if ms_since_call > self.arc_points:
+            ms_since_call = self.arc_points
+        angle_change = (theta_end - theta_start) / self.arc_points
+        theta_i = theta_start + ms_since_call * angle_change
+        self.x_i = center_x + radius * math.cos(theta_i)
+        self.y_i = center_y + radius * 0.5 * math.sin(theta_i)
+
+        eighth_in_ms = (60000 * 4 / game_screen.tja.bpm) / 8
+        current_eighth = int(game_screen.current_ms // eighth_in_ms)
+        ray.draw_texture(self.note_type[current_eighth % 2], int(self.x_i), int(self.y_i), ray.WHITE)
+
+class DrumrollCounter:
+    def __init__(self, current_ms):
+        self.create_ms = current_ms
+        self.is_finished = False
+        self.total_duration = 1349
+        self.drumroll_count = 0
+        self.fade = 1
+        self.color = ray.fade(ray.WHITE, self.fade)
+        self.counter_stretch = 0
+        self.start_stretch = None
+        self.is_stretching = False
+
+    def update_count(self, current_ms, count, elapsed_time):
+        self.total_duration = elapsed_time + 1349
+        if self.drumroll_count != count:
+            self.drumroll_count = count
+            self.start_stretch = current_ms
+            self.is_stretching = True
+
+    def update_stretch(self, current_ms):
+        if not self.is_stretching:
+            return
+        elapsed_time = current_ms - self.start_stretch
+        if elapsed_time <= 50:
+            self.counter_stretch = 2 + 5 * (elapsed_time // 25)
+        elif elapsed_time <= 50 + 116:
+            frame_time = (elapsed_time - 50) // 16.57
+            self.counter_stretch = 2 + 10 - (2 * (frame_time + 1))
+        else:
+            self.counter_stretch = 0
+            self.is_stretching = False
+
+    def update(self, game_screen, current_ms, drumroll_count):
+        self.update_stretch(current_ms)
+
+        elapsed_time = current_ms - self.create_ms
+        if drumroll_count != 0:
+            self.update_count(current_ms, drumroll_count, elapsed_time)
+        fade_start_time = self.total_duration - 166
+        if elapsed_time >= fade_start_time:
+            fade_progress = (elapsed_time - fade_start_time) / 166
+            self.fade = 1 - fade_progress
+            self.color = ray.fade(ray.WHITE, self.fade)
+        if elapsed_time > self.total_duration:
+            self.is_finished = True
+
+    def draw(self, game_screen):
+        ray.draw_texture(game_screen.texture_drumroll_count, 200, 0, self.color)
+        counter = str(self.drumroll_count)
+        total_width = len(counter) * 52
+        start_x = 344 - (total_width // 2)
+        source_rect = ray.Rectangle(0, 0, game_screen.texture_drumroll_number[0].width, game_screen.texture_drumroll_number[0].height)
+        for i in range(len(counter)):
+            dest_rect = ray.Rectangle(start_x + (i * 52), 50 - self.counter_stretch, game_screen.texture_drumroll_number[0].width, game_screen.texture_drumroll_number[0].height + self.counter_stretch)
+            ray.draw_texture_pro(game_screen.texture_balloon_number[int(counter[i])], source_rect, dest_rect, ray.Vector2(0,0), 0, self.color)
+
+class BalloonAnimation:
+    def __init__(self, current_ms, balloon_total):
+        self.create_ms = current_ms
+        self.is_finished = False
+        self.total_duration = 83.33
+        self.fade = 1
+        self.color = ray.fade(ray.WHITE, self.fade)
+        self.balloon_count = 0
+        self.balloon_total = balloon_total
+        self.is_popped = False
+        self.counter_stretch = 0
+        self.start_stretch = None
+        self.is_stretching = False
+
+    def update_count(self, current_ms, balloon_count):
+        if self.balloon_count != balloon_count:
+            self.balloon_count = balloon_count
+            self.start_stretch = current_ms
+            self.is_stretching = True
+
+    def update_stretch(self, current_ms):
+        if not self.is_stretching:
+            return
+        elapsed_time = current_ms - self.start_stretch
+        if elapsed_time <= 50:
+            self.counter_stretch = 2 + 5 * (elapsed_time // 25)
+        elif elapsed_time <= 50 + 116:
+            frame_time = (elapsed_time - 50) // 16.57
+            self.counter_stretch = 2 + 10 - (2 * (frame_time + 1))
+        else:
+            self.counter_stretch = 0
+            self.is_stretching = False
+
+    def update(self, game_screen, current_ms, balloon_count, is_popped):
+        self.update_count(current_ms, balloon_count)
+        self.update_stretch(current_ms)
+        self.is_popped = is_popped
+
+        elapsed_time = current_ms - self.create_ms
+        fade_start_time = self.total_duration - 166
+        if self.is_popped:
+            if elapsed_time >= fade_start_time:
+                fade_progress = (elapsed_time - fade_start_time) / 166
+                self.fade = 1 - fade_progress
+                self.color = ray.fade(ray.WHITE, self.fade)
+            if elapsed_time > self.total_duration:
+                self.is_finished = True
+        else:
+            self.total_duration = elapsed_time + 166
+
+    def draw(self, game_screen):
+        if self.is_popped:
+            ray.draw_texture(game_screen.texture_balloon[7], 460, 130, self.color)
+        elif self.balloon_count >= 1:
+            balloon_index = (self.balloon_count - 1) * 7 // self.balloon_total
+            ray.draw_texture(game_screen.texture_balloon[balloon_index], 460, 130, self.color)
+        if self.balloon_count > 0:
+            ray.draw_texture(game_screen.texture_balloon_speech_bubble_p1, 414, 40, ray.WHITE)
+            counter = str(self.balloon_total - self.balloon_count + 1)
+            x, y = 493, 68
+            margin = 52
+            total_width = len(counter) * margin
+            start_x = x - (total_width // 2)
+            source_rect = ray.Rectangle(0, 0, game_screen.texture_balloon_number[0].width, game_screen.texture_balloon_number[0].height)
+            for i in range(len(counter)):
+                dest_rect = ray.Rectangle(start_x + (i * margin), y - self.counter_stretch, game_screen.texture_balloon_number[0].width, game_screen.texture_balloon_number[0].height + self.counter_stretch)
+                ray.draw_texture_pro(game_screen.texture_balloon_number[int(counter[i])], source_rect, dest_rect, ray.Vector2(0,0), 0, self.color)
+
+class Combo:
+    def __init__(self, combo, current_ms):
+        self.combo = combo
+        self.counter_stretch = 0
+        self.start_stretch = None
+        self.is_stretching = False
+        self.color = [ray.fade(ray.WHITE, 1), ray.fade(ray.WHITE, 1), ray.fade(ray.WHITE, 1)]
+        self.glimmer_dict = {0: 0, 1: 0, 2: 0}
+        self.total_time = 250
+        self.cycle_time = self.total_time * 2
+        self.start_times = [
+                    current_ms,
+                    current_ms + (2 / 3) * self.cycle_time,
+                    current_ms + (4 / 3) * self.cycle_time
+                ]
+
+    def update_count(self, current_ms, combo):
+        if self.combo != combo:
+            self.combo = combo
+            self.start_stretch = current_ms
+            self.is_stretching = True
+
+    def update_stretch(self, current_ms):
+        if not self.is_stretching:
+            return
+        elapsed_time = current_ms - self.start_stretch
+        if elapsed_time <= 50:
+            self.counter_stretch = 2 + (5 * (elapsed_time // 25))
+        elif elapsed_time <= 50 + 100:
+            frame_time = (elapsed_time - 50) // 16.57
+            self.counter_stretch = 2 + (10 - (2 * (frame_time + 1)))
+        else:
+            self.counter_stretch = 0
+            self.is_stretching = False
+
+    def update(self, game_screen, current_ms, combo):
+        self.update_count(current_ms, combo)
+        self.update_stretch(current_ms)
+
+        for i in range(3):
+            elapsed_time = current_ms - self.start_times[i]
+            if elapsed_time > self.cycle_time:
+                cycles_completed = elapsed_time // self.cycle_time
+                self.start_times[i] += cycles_completed * self.cycle_time
+                elapsed_time = current_ms - self.start_times[i]
+            if elapsed_time <= self.total_time:
+                self.glimmer_dict[i] = -int(elapsed_time // 16.67)
+                fade_start_time = self.total_time - 164
+                if elapsed_time >= fade_start_time:
+                    fade = 1 - (elapsed_time - fade_start_time) / 164
+                else:
+                    fade = 1
+            else:
+                self.glimmer_dict[i] = 0
+                fade = 0
+            self.color[i] = ray.fade(ray.WHITE, fade)
+
+    def draw(self, game_screen):
+        if self.combo < 100:
+            text_color = 0
+            margin = 30
+        else:
+            text_color = 1
+            margin = 35
+        ray.draw_texture(game_screen.texture_combo_text[text_color], 234, 265, ray.WHITE)
+        counter = str(self.combo)
+        total_width = len(counter) * margin
+        x, y = 262, 220
+        start_x = x - (total_width // 2)
+        source_rect = ray.Rectangle(0, 0, game_screen.texture_combo_numbers[0].width, game_screen.texture_combo_numbers[0].height)
+        for i in range(len(counter)):
+            dest_rect = ray.Rectangle(start_x + (i * margin), y - self.counter_stretch, game_screen.texture_combo_numbers[0].width, game_screen.texture_combo_numbers[0].height + self.counter_stretch)
+            ray.draw_texture_pro(game_screen.texture_combo_numbers[int(counter[i]) + (text_color*10)], source_rect, dest_rect, ray.Vector2(0,0), 0, ray.WHITE)
+        glimmer_positions = [(225, 210), (200, 230), (250, 230)]
+        if self.combo >= 100:
+            for j, (x, y) in enumerate(glimmer_positions):
+                for i in range(3):
+                    ray.draw_texture(game_screen.texture_combo_glimmer, x + (i * 30), y + self.glimmer_dict[j], self.color[j])

global_funcs.py

@@ -0,0 +1,235 @@
+import time
+import os
+import simpleaudio as sa
+import pyray as ray
+
+from collections import deque
+
+#TJA Format creator is unknown. I did not create the format, but I did write the parser though.
+
+def rounded(d):
+    sign = 1 if (d >= 0) else -1
+    d = abs(d)
+    n = int(d)
+    if (d - n >= 0.5): n += 1
+    return sign * n
+
+def get_current_ms():
+    return rounded(time.time() * 1000)
+
+def stripComments(code):
+    result = ''
+    index = 0
+    is_line = True
+    for line in code.splitlines():
+        comment_index = line.find('//')
+        if comment_index == -1:
+            result += line
+            is_line = True
+        elif comment_index != 0 and not line[:comment_index].isspace():
+            result += line[:comment_index]
+            is_line = True
+        else:
+            is_line = False
+        index += 1
+    return result
+
+def get_pixels_per_frame(bpm, fps, time_signature, distance):
+    beat_duration = fps / bpm
+    total_time = time_signature * beat_duration
+    total_frames = fps * total_time
+    return (distance / total_frames) * (fps/60)
+
+class tja_parser:
+    def __init__(self, path):
+        #Defined on startup
+        self.folder_path = path
+        self.folder_name = self.folder_path.split('\\')[-1]
+        self.file_path = f'{self.folder_path}\\{self.folder_name}.tja'
+
+        #Defined on file_to_data()
+        self.data = []
+
+        #Defined on get_metadata()
+        self.title = ''
+        self.title_ja = ''
+        self.subtitle = ''
+        self.subtitle_ja = ''
+        self.wave = f'{self.folder_path}\\'
+        self.offset = 0
+        self.demo_start = 0
+        self.course_data = dict()
+
+        #Defined in metadata but can change throughout the chart
+        self.bpm = 120
+        self.time_signature = 4/4
+
+        self.distance = 0
+        self.fps = 60
+        self.scroll_modifier = 1
+        self.current_ms = 0
+        self.barline_display = True
+
+    def file_to_data(self):
+        with open(self.file_path, 'rt', encoding='utf-8-sig') as tja_file:
+            for line in tja_file:
+                line = stripComments(line).strip()
+                if line != '':
+                    self.data.append(str(line))
+            return self.data
+
+    def get_metadata(self):
+        self.file_to_data()
+        diff_index = 1
+        highest_diff = -1
+        for item in self.data:
+            if item[0] == '#':
+                continue
+            elif 'SUBTITLEJA' in item: self.subtitle_ja = str(item.split('SUBTITLEJA:')[1])
+            elif 'TITLEJA' in item: self.title_ja = str(item.split('TITLEJA:')[1])
+            elif 'SUBTITLE' in item: self.subtitle = str(item.split('SUBTITLE:')[1][2:])
+            elif 'TITLE' in item: self.title = str(item.split('TITLE:')[1])
+            elif 'BPM' in item: self.bpm = float(item.split(':')[1])
+            elif 'WAVE' in item: self.wave += str(item.split(':')[1])
+            elif 'OFFSET' in item: self.offset = float(item.split(':')[1])
+            elif 'DEMOSTART' in item: self.demo_start = float(item.split(':')[1])
+            elif 'COURSE' in item:
+                course = str(item.split(':')[1]).lower()
+                if course == 'edit' or course == '4':
+                    self.course_data[4] = []
+                elif course == 'oni' or course == '3':
+                    self.course_data[3] = []
+                elif course == 'hard' or course == '2':
+                    self.course_data[2] = []
+                elif course == 'normal' or course == '1':
+                    self.course_data[1] = []
+                elif course == 'easy' or course == '0':
+                    self.course_data[0] = []
+                highest_diff = max(self.course_data)
+                diff_index -= 1
+            elif 'LEVEL' in item:
+                item = int(item.split(':')[1])
+                self.course_data[diff_index+highest_diff].append(item)
+            elif 'BALLOON' in item:
+                item = item.split(':')[1]
+                if item == '':
+                    continue
+                self.course_data[diff_index+highest_diff].append([int(x) for x in item.split(',')])
+            elif 'SCOREINIT' in item:
+                if item.split(':')[1] == '':
+                    continue
+                item = item.split(':')[1]
+                self.course_data[diff_index+highest_diff].append([int(x) for x in item.split(',')])
+            elif 'SCOREDIFF' in item:
+                if item.split(':')[1] == '':
+                    continue
+                item = int(item.split(':')[1])
+                self.course_data[diff_index+highest_diff].append(item)
+        return [self.title, self.title_ja, self.subtitle, self.subtitle_ja, self.bpm, self.wave, self.offset, self.demo_start, self.course_data]
+
+    def data_to_notes(self, diff):
+        self.file_to_data()
+        #Get notes start and end
+        note_start = -1
+        note_end = -1
+        diff_count = 0
+        for i in range(len(self.data)):
+            if self.data[i] == '#START':
+                note_start = i+1
+            elif self.data[i] == '#END':
+                note_end = i
+                diff_count += 1
+            if diff_count == len(self.course_data) - diff:
+                break
+
+        notes = []
+        bar = []
+        #Check for measures and separate when comma exists
+        for i in range(note_start, note_end):
+            item = self.data[i].strip(',')
+            bar.append(item)
+            if item != self.data[i]:
+                notes.append(bar)
+                bar = []
+        return notes, self.course_data[diff][1]
+
+    def notes_to_position(self, diff):
+        play_note_list = deque()
+        bar_list = deque()
+        draw_note_list = deque()
+        notes, balloon = self.data_to_notes(diff)
+        index = 0
+        balloon_index = 0
+        drumroll_head = dict()
+        drumroll_tail = dict()
+        for bar in notes:
+            #Length of the bar is determined by number of notes excluding commands
+            bar_length = sum(len(part) for part in bar if '#' not in part)
+
+            for part in bar:
+                if '#JPOSSCROLL' in part:
+                    continue
+                elif '#NMSCROLL' in part:
+                    continue
+                elif '#MEASURE' in part:
+                    divisor = part.find('/')
+                    self.time_signature = float(part[9:divisor]) / float(part[divisor+1:])
+                    continue
+                elif '#SCROLL' in part:
+                    self.scroll_modifier = float(part[7:])
+                    continue
+                elif '#BPMCHANGE' in part:
+                    self.bpm = float(part[11:])
+                    continue
+                elif '#BARLINEOFF' in part:
+                    self.barline_display = False
+                    continue
+                elif '#BARLINEON' in part:
+                    self.barline_display = True
+                    continue
+                #Unrecognized commands will be skipped for now
+                elif '#' in part:
+                    continue
+
+                #https://gist.github.com/KatieFrogs/e000f406bbc70a12f3c34a07303eec8b#measure
+                ms_per_measure = 60000 * (self.time_signature*4) / self.bpm
+
+                #Determines how quickly the notes need to move across the screen to reach the judgment circle in time
+                pixels_per_frame = get_pixels_per_frame(self.bpm * self.time_signature * self.scroll_modifier, self.fps, self.time_signature*4, self.distance)
+                pixels_per_ms = pixels_per_frame / (1000 / self.fps)
+
+                bar_ms = self.current_ms
+                load_ms = bar_ms - (self.distance / pixels_per_ms)
+
+                if self.barline_display:
+                    bar_list.append({'note': 'barline', 'ms': bar_ms, 'load_ms': load_ms, 'ppf': pixels_per_frame})
+
+                #Empty bar is still a bar, otherwise start increment
+                if len(part) == 0:
+                    self.current_ms += ms_per_measure
+                    increment = 0
+                else:
+                    increment = ms_per_measure / bar_length
+
+                for note in part:
+                    note_ms = self.current_ms
+                    load_ms = note_ms - (self.distance / pixels_per_ms)
+                    #Do not add blank notes otherwise lag
+                    if note != '0':
+                        play_note_list.append({'note': note, 'ms': note_ms, 'load_ms': load_ms, 'ppf': pixels_per_frame, 'index': index})
+                        #print({'note': note, 'ms': int(note_ms), 'load_ms': int(load_ms), 'ppf': int(pixels_per_frame), 'index': index})
+                        index += 1
+                    if note in ('5', '6', '8'):
+                        play_note_list[-1]['color'] = 255
+                    if note == '8' and play_note_list[-2]['note'] in ('7', '9'):
+                        play_note_list[-1]['balloon'] = int(balloon[balloon_index])
+                        balloon_index += 1
+                    self.current_ms += increment
+
+        # https://stackoverflow.com/questions/72899/how-to-sort-a-list-of-dictionaries-by-a-value-of-the-dictionary-in-python
+        # Sorting by load_ms is necessary for drawing, as some notes appear on the
+        # screen slower regardless of when they reach the judge circle
+        # Bars can be sorted like this because they don't need hit detection
+        draw_note_list = deque(sorted(play_note_list, key=lambda d: d['load_ms']))
+        bar_list = deque(sorted(bar_list, key=lambda d: d['load_ms']))
+        return play_note_list, draw_note_list, bar_list

main.py

@@ -0,0 +1,64 @@
+import pyray as ray
+
+from entry import *
+from game import *
+
+class Screens:
+    TITLE = "TITLE"
+    ENTRY = "ENTRY"
+    SONG_SELECT = "SONG_SELECT"
+    GAME = "GAME"
+    RESULT = "RESULT"
+
+def main():
+    screen_width = 1280
+    screen_height = 720
+
+    ray.set_config_flags(ray.ConfigFlags.FLAG_VSYNC_HINT)
+
+    ray.set_window_max_size(screen_width, screen_height)
+    ray.set_window_min_size(screen_width, screen_height)
+    ray.init_window(screen_width, screen_height, "PyTaiko")
+
+    current_screen = Screens.ENTRY
+    frames_counter = 0
+
+    ray.init_audio_device()
+
+    entry_screen = EntryScreen(screen_width, screen_height)
+    game_screen = GameScreen(screen_width, screen_height)
+
+    screen_mapping = {
+        Screens.ENTRY: entry_screen,
+        #Screens.TITLE: title_screen,
+        #Screens.SONG_SELECT: song_select_screen,
+        Screens.GAME: game_screen,
+        #Screens.RESULT: result_screen
+    }
+
+    #ray.set_target_fps(144)
+    start_song = False
+    while not ray.window_should_close():
+        ray.begin_drawing()
+        ray.clear_background(ray.WHITE)
+
+        if ray.is_key_pressed(ray.KeyboardKey.KEY_F11):
+            ray.toggle_fullscreen()
+
+        screen = screen_mapping[current_screen]
+        if screen == game_screen and not start_song:
+            game_screen.init_tja()
+            start_song = True
+        next_screen = screen.update()
+        screen.draw()
+
+        if next_screen is not None:
+            current_screen = next_screen
+
+        ray.draw_fps(20, 20)
+        ray.end_drawing()
+    ray.close_window()
+    ray.close_audio_device()
+
+if __name__ == "__main__":
+    main()