From de293cc2359679cff0f84fe84fc9fbc96ed72e66 Mon Sep 17 00:00:00 2001 From: Yonokid <37304577+Yonokid@users.noreply.github.com> Date: Tue, 20 Aug 2024 03:14:51 -0400 Subject: [PATCH] Add files --- .gitignore | 1 + entry.py | 16 + game.py | 949 ++++++++++++++++++++++++++++++++++++++++++++++++ global_funcs.py | 235 ++++++++++++ main.py | 64 ++++ 5 files changed, 1265 insertions(+) create mode 100644 .gitignore create mode 100644 entry.py create mode 100644 game.py create mode 100644 global_funcs.py create mode 100644 main.py diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..ec698ab --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +Songs \ No newline at end of file diff --git a/entry.py b/entry.py new file mode 100644 index 0000000..88c6389 --- /dev/null +++ b/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) diff --git a/game.py b/game.py new file mode 100644 index 0000000..5b3be9e --- /dev/null +++ b/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]) diff --git a/global_funcs.py b/global_funcs.py new file mode 100644 index 0000000..eacf4d2 --- /dev/null +++ b/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 diff --git a/main.py b/main.py new file mode 100644 index 0000000..f1c6c9d --- /dev/null +++ b/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()