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

refactoring

Browse Source
This commit is contained in:
Yonokid
2025-04-23 19:14:09 -04:00
parent 0012868d4e
commit 3291eccdcd
11 changed files with 634 additions and 482 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
config.toml
View File

@@ -7,16 +7,18 @@ tja_path = 'Songs'
video_path = 'Videos' video_path = 'Videos'
[keybinds] [keybinds]
left_kat = 'E' left_kat = ['E','R']
left_don = 'F' left_don = ['F','K']
right_don = 'J' right_don = ['J','D']
right_kat = 'I' right_kat = ['I','U']
[audio] [audio]
device_type = 'ASIO' device_type = 'ASIO'
asio_buffer = 6 asio_buffer = 6
[video] [video]
fullscreen = true screen_width = 1280
borderless = true screen_height = 720
fullscreen = false
borderless = false
vsync = true vsync = true

22
libs/animation.py
View File

@@ -1,5 +1,5 @@
class Animation: class Animation:
def __init__(self, current_ms, duration, type): def __init__(self, current_ms: float, duration: float, type: str):
self.type = type self.type = type
self.start_ms = current_ms self.start_ms = current_ms
self.attribute = 0 self.attribute = 0
@@ -7,7 +7,7 @@ class Animation:
self.params = dict() self.params = dict()
self.is_finished = False self.is_finished = False
def update(self, current_ms): def update(self, current_ms: float):
if self.type == 'fade': if self.type == 'fade':
self.fade(current_ms, self.fade(current_ms,
self.duration, self.duration,
@@ -50,8 +50,8 @@ class Animation:
initial_size=self.params.get('final_size', 1.0), initial_size=self.params.get('final_size', 1.0),
delay=self.params.get('delay', 0.0) + self.duration) delay=self.params.get('delay', 0.0) + self.duration)
def fade(self, current_ms, duration, initial_opacity, final_opacity, delay, ease_in, ease_out): def fade(self, current_ms: float, duration: float, initial_opacity: float, final_opacity: float, delay: float, ease_in: str | None, ease_out: str | None) -> None:
def ease_out_progress(progress, ease): def _ease_out_progress(progress: float, ease: str | None) -> float:
if ease == 'quadratic': if ease == 'quadratic':
return progress * (2 - progress) return progress * (2 - progress)
elif ease == 'cubic': elif ease == 'cubic':
@@ -60,7 +60,7 @@ class Animation:
return 1 - pow(2, -10 * progress) return 1 - pow(2, -10 * progress)
else: else:
return progress return progress
def ease_in_progress(progress, ease): def _ease_in_progress(progress: float, ease: str | None) -> float:
if ease == 'quadratic': if ease == 'quadratic':
return progress * progress return progress * progress
elif ease == 'cubic': elif ease == 'cubic':
@@ -79,15 +79,15 @@ class Animation:
self.is_finished = True self.is_finished = True
if ease_in is not None: if ease_in is not None:
progress = ease_in_progress(elapsed_time / duration, ease_in) progress = _ease_in_progress(elapsed_time / duration, ease_in)
elif ease_out is not None: elif ease_out is not None:
progress = ease_out_progress(elapsed_time / duration, ease_out) progress = _ease_out_progress(elapsed_time / duration, ease_out)
else: else:
progress = elapsed_time / duration progress = elapsed_time / duration
current_opacity = initial_opacity + (final_opacity - initial_opacity) * progress current_opacity = initial_opacity + (final_opacity - initial_opacity) * progress
self.attribute = current_opacity self.attribute = current_opacity
def move(self, current_ms, duration, total_distance, start_position, delay): def move(self, current_ms: float, duration: float, total_distance: float, start_position: float, delay: float) -> None:
elapsed_time = current_ms - self.start_ms elapsed_time = current_ms - self.start_ms
if elapsed_time < delay: if elapsed_time < delay:
self.attribute = start_position self.attribute = start_position
@@ -99,7 +99,7 @@ class Animation:
else: else:
self.attribute = start_position + total_distance self.attribute = start_position + total_distance
self.is_finished = True self.is_finished = True
def texture_change(self, current_ms, duration, textures): def texture_change(self, current_ms: float, duration: float, textures: list[tuple[float, float, float]]) -> None:
elapsed_time = current_ms - self.start_ms elapsed_time = current_ms - self.start_ms
if elapsed_time <= duration: if elapsed_time <= duration:
for start, end, index in textures: for start, end, index in textures:
@@ -107,7 +107,7 @@ class Animation:
self.attribute = index self.attribute = index
else: else:
self.is_finished = True self.is_finished = True
def text_stretch(self, current_ms, duration): def text_stretch(self, current_ms: float, duration: float):
elapsed_time = current_ms - self.start_ms elapsed_time = current_ms - self.start_ms
if elapsed_time <= duration: if elapsed_time <= duration:
self.attribute = 2 + 5 * (elapsed_time // 25) self.attribute = 2 + 5 * (elapsed_time // 25)
@@ -117,7 +117,7 @@ class Animation:
else: else:
self.attribute = 0 self.attribute = 0
self.is_finished = True self.is_finished = True
def texture_resize(self, current_ms, duration, initial_size, final_size, delay): def texture_resize(self, current_ms: float, duration: float, initial_size: float, final_size: float, delay: float):
elapsed_time = current_ms - self.start_ms elapsed_time = current_ms - self.start_ms
if elapsed_time < delay: if elapsed_time < delay:
self.attribute = initial_size self.attribute = initial_size

30
libs/tja.py
View File

@@ -4,7 +4,7 @@ from collections import deque
from libs.utils import get_pixels_per_frame, strip_comments from libs.utils import get_pixels_per_frame, strip_comments
def calculate_base_score(play_note_list: list[dict]) -> int: def calculate_base_score(play_note_list: deque[dict]) -> int:
total_notes = 0 total_notes = 0
balloon_num = 0 balloon_num = 0
balloon_count = 0 balloon_count = 0
@@ -55,7 +55,7 @@ class TJAParser:
self.barline_display = True self.barline_display = True
self.gogo_time = False self.gogo_time = False
def file_to_data(self): def _file_to_data(self):
with open(self.file_path, 'rt', encoding='utf-8-sig') as tja_file: with open(self.file_path, 'rt', encoding='utf-8-sig') as tja_file:
for line in tja_file: for line in tja_file:
line = strip_comments(line).strip() line = strip_comments(line).strip()
@@ -64,7 +64,7 @@ class TJAParser:
return self.data return self.data
def get_metadata(self): def get_metadata(self):
self.file_to_data() self._file_to_data()
diff_index = 1 diff_index = 1
highest_diff = -1 highest_diff = -1
for item in self.data: for item in self.data:
@@ -126,7 +126,7 @@ class TJAParser:
self.bpm, self.wave, self.offset, self.demo_start, self.course_data] self.bpm, self.wave, self.offset, self.demo_start, self.course_data]
def data_to_notes(self, diff): def data_to_notes(self, diff):
self.file_to_data() self._file_to_data()
#Get notes start and end #Get notes start and end
note_start = -1 note_start = -1
note_end = -1 note_end = -1
@@ -144,11 +144,23 @@ class TJAParser:
bar = [] bar = []
#Check for measures and separate when comma exists #Check for measures and separate when comma exists
for i in range(note_start, note_end): for i in range(note_start, note_end):
item = self.data[i].strip(',') line = self.data[i]
bar.append(item) if line.startswith("#"):
if item != self.data[i]: bar.append(line)
notes.append(bar) else:
bar = [] item = line.strip(',')
if item == '':
if bar == []:
bar.append(item)
else:
notes.append(bar)
bar = []
continue
else:
bar.append(item)
if item != line:
notes.append(bar)
bar = []
return notes, self.course_data[diff][1] return notes, self.course_data[diff][1]
def get_se_note(self, play_note_list, ms_per_measure, note, note_ms): def get_se_note(self, play_note_list, ms_per_measure, note, note_ms):

98
libs/utils.py
View File

@@ -10,6 +10,14 @@ import tomllib
#TJA Format creator is unknown. I did not create the format, but I did write the parser though. #TJA Format creator is unknown. I did not create the format, but I did write the parser though.
def get_zip_filenames(zip_path: str) -> list[str]:
result = []
with zipfile.ZipFile(zip_path, 'r') as zip_ref:
file_list = zip_ref.namelist()
for file_name in file_list:
result.append(file_name)
return result
def load_image_from_zip(zip_path: str, filename: str) -> ray.Image: def load_image_from_zip(zip_path: str, filename: str) -> ray.Image:
with zipfile.ZipFile(zip_path, 'r') as zip_ref: with zipfile.ZipFile(zip_path, 'r') as zip_ref:
with zip_ref.open(filename) as image_file: with zip_ref.open(filename) as image_file:
@@ -30,6 +38,28 @@ def load_texture_from_zip(zip_path: str, filename: str) -> ray.Texture:
os.remove(temp_file_path) os.remove(temp_file_path)
return texture return texture
def load_all_textures_from_zip(zip_path: str) -> dict[str, list[ray.Texture]]:
result_dict = dict()
with zipfile.ZipFile(zip_path, 'r') as zip_ref:
files = zip_ref.namelist()
for file in files:
with zip_ref.open(file) as image_file:
with tempfile.NamedTemporaryFile(delete=False, suffix='.png') as temp_file:
temp_file.write(image_file.read())
temp_file_path = temp_file.name
texture = ray.load_texture(temp_file_path)
os.remove(temp_file_path)
true_filename, index = file.split('_img')
index = int(index.split('.')[0])
if true_filename not in result_dict:
result_dict[true_filename] = []
while len(result_dict[true_filename]) <= index:
result_dict[true_filename].append(None)
result_dict[true_filename][index] = texture
return result_dict
def rounded(num: float) -> int: def rounded(num: float) -> int:
sign = 1 if (num >= 0) else -1 sign = 1 if (num >= 0) else -1
num = abs(num) num = abs(num)
@@ -41,7 +71,7 @@ def rounded(num: float) -> int:
def get_current_ms() -> int: def get_current_ms() -> int:
return rounded(time.time() * 1000) return rounded(time.time() * 1000)
def strip_comments(code: str): def strip_comments(code: str) -> str:
result = '' result = ''
index = 0 index = 0
for line in code.splitlines(): for line in code.splitlines():
@@ -53,7 +83,7 @@ def strip_comments(code: str):
index += 1 index += 1
return result return result
def get_pixels_per_frame(bpm: float, time_signature: float, distance: float): def get_pixels_per_frame(bpm: float, time_signature: float, distance: float) -> float:
beat_duration = 60 / bpm beat_duration = 60 / bpm
total_time = time_signature * beat_duration total_time = time_signature * beat_duration
total_frames = 60 * total_time total_frames = 60 * total_time
@@ -66,6 +96,7 @@ def get_config() -> dict[str, Any]:
@dataclass @dataclass
class GlobalData: class GlobalData:
videos_cleared = False
start_song: bool = False start_song: bool = False
selected_song: str = '' selected_song: str = ''
selected_difficulty: int = -1 selected_difficulty: int = -1
@@ -73,3 +104,66 @@ class GlobalData:
result_ok: int = -1 result_ok: int = -1
result_bad: int = -1 result_bad: int = -1
result_score: int = -1 result_score: int = -1
songs_played: int = 0
global_data = GlobalData()
@dataclass
class OutlinedText:
font: ray.Font
text: str
font_size: int
text_color: ray.Color
outline_color: ray.Color
outline_thickness: int = 2
def __post_init__(self):
self.texture = self._create_texture()
def _create_texture(self):
text_size = ray.measure_text_ex(self.font, self.text, self.font_size, 1.0)
padding = self.outline_thickness * 2
width = int(text_size.x + padding * 2)
height = int(text_size.y + padding * 2)
image = ray.gen_image_color(width, height, ray.Color(0, 0, 0, 0))
for dx in range(-self.outline_thickness, self.outline_thickness + 1):
for dy in range(-self.outline_thickness, self.outline_thickness + 1):
if dx == 0 and dy == 0:
continue
distance = (dx * dx + dy * dy) ** 0.5
if distance <= self.outline_thickness:
ray.image_draw_text_ex(
image,
self.font,
self.text,
ray.Vector2(padding + dx, padding + dy),
self.font_size,
1.0,
self.outline_color
)
ray.image_draw_text_ex(
image,
self.font,
self.text,
ray.Vector2(padding, padding),
self.font_size,
1.0,
self.text_color
)
texture = ray.load_texture_from_image(image)
ray.unload_image(image)
return texture
def draw(self, x: int, y: int, color: ray.Color):
ray.draw_texture(self.texture, x, y, color)
def unload(self):
ray.unload_texture(self.texture)

19
libs/video.py
View File

@@ -21,25 +21,26 @@ class VideoPlayer:
audio_path = path[:-4] + '.ogg' audio_path = path[:-4] + '.ogg'
self.audio = audio.load_music_stream(audio_path) self.audio = audio.load_music_stream(audio_path)
def convert_frames_background(self, index: int): def _convert_frames_background(self):
if not self.cap.isOpened(): if not self.cap.isOpened():
raise ValueError("Error: Could not open video file.") raise ValueError("Error: Could not open video file.")
total_frames = int(self.cap.get(cv2.CAP_PROP_FRAME_COUNT)) total_frames = int(self.cap.get(cv2.CAP_PROP_FRAME_COUNT))
if len(self.frames) == total_frames: if len(self.frames) == total_frames:
return 0 return 0
self.cap.set(cv2.CAP_PROP_POS_FRAMES, index) self.cap.set(cv2.CAP_PROP_POS_FRAMES, self.frame_index)
success, frame = self.cap.read() success, frame = self.cap.read()
timestamp = (index / self.fps * 1000) timestamp = (self.frame_index / self.fps * 1000)
frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
new_frame = ray.Image(frame_rgb.tobytes(), frame_rgb.shape[1], frame_rgb.shape[0], 1, ray.PixelFormat.PIXELFORMAT_UNCOMPRESSED_R8G8B8) new_frame = ray.Image(frame_rgb.tobytes(), frame_rgb.shape[1], frame_rgb.shape[0], 1, ray.PixelFormat.PIXELFORMAT_UNCOMPRESSED_R8G8B8)
self.frames.append((timestamp, new_frame)) self.frames.append((timestamp, new_frame))
self.frame_index += 1
def convert_frames(self): def _convert_frames(self):
if not self.cap.isOpened(): if not self.cap.isOpened():
raise ValueError("Error: Could not open video file.") raise ValueError("Error: Could not open video file.")
@@ -61,13 +62,13 @@ class VideoPlayer:
print(f"Extracted {len(self.frames)} frames.") print(f"Extracted {len(self.frames)} frames.")
self.start_ms = get_current_ms() self.start_ms = get_current_ms()
def check_for_start(self): def _check_for_start(self):
if self.frames == []: if self.frames == []:
self.convert_frames() self._convert_frames()
if not audio.is_music_stream_playing(self.audio): if not audio.is_music_stream_playing(self.audio):
audio.play_music_stream(self.audio) audio.play_music_stream(self.audio)
def audio_manager(self): def _audio_manager(self):
audio.update_music_stream(self.audio) audio.update_music_stream(self.audio)
time_played = audio.get_music_time_played(self.audio) / audio.get_music_time_length(self.audio) time_played = audio.get_music_time_played(self.audio) / audio.get_music_time_length(self.audio)
ending_lenience = 0.95 ending_lenience = 0.95
@@ -75,8 +76,8 @@ class VideoPlayer:
self.is_finished[1] = True self.is_finished[1] = True
def update(self): def update(self):
self.check_for_start() self._check_for_start()
self.audio_manager() self._audio_manager()
if self.frame_index == len(self.frames)-1: if self.frame_index == len(self.frames)-1:
self.is_finished[0] = True self.is_finished[0] = True

13
main.py
View File

@@ -1,7 +1,7 @@
import pyray as ray import pyray as ray
from libs.audio import audio from libs.audio import audio
from libs.utils import GlobalData, get_config from libs.utils import get_config, global_data
from scenes.entry import EntryScreen from scenes.entry import EntryScreen
from scenes.game import GameScreen from scenes.game import GameScreen
from scenes.result import ResultScreen from scenes.result import ResultScreen
@@ -17,8 +17,8 @@ class Screens:
RESULT = "RESULT" RESULT = "RESULT"
def main(): def main():
screen_width = 1280 screen_width: int = get_config()["video"]["screen_width"]
screen_height = 720 screen_height: int = get_config()["video"]["screen_height"]
if get_config()["video"]["vsync"]: if get_config()["video"]["vsync"]:
ray.set_config_flags(ray.ConfigFlags.FLAG_VSYNC_HINT) ray.set_config_flags(ray.ConfigFlags.FLAG_VSYNC_HINT)
@@ -65,15 +65,16 @@ def main():
if ray.is_key_pressed(ray.KeyboardKey.KEY_F11): if ray.is_key_pressed(ray.KeyboardKey.KEY_F11):
ray.toggle_fullscreen() ray.toggle_fullscreen()
ray.is_window_fullscreen()
elif ray.is_key_pressed(ray.KeyboardKey.KEY_F12):
ray.toggle_borderless_windowed()
next_screen = screen.update() next_screen = screen.update()
screen.draw() screen.draw()
if screen == title_screen: if screen == title_screen:
ray.clear_background(ray.BLACK) ray.clear_background(ray.BLACK)
else: else:
if not global_data.videos_cleared:
del title_screen.op_video
del title_screen.attract_video
global_data.videos_cleared = True
ray.clear_background(ray.WHITE) ray.clear_background(ray.WHITE)
if next_screen is not None: if next_screen is not None:

2
scenes/entry.py
View File

@@ -4,7 +4,7 @@ from libs.utils import load_texture_from_zip
class EntryScreen: class EntryScreen:
def __init__(self, width, height): def __init__(self, width: int, height: int):
self.width = width self.width = width
self.height = height self.height = height

465
scenes/game.py
View File

@@ -8,16 +8,18 @@ from libs.animation import Animation
from libs.audio import audio from libs.audio import audio
from libs.tja import TJAParser, calculate_base_score from libs.tja import TJAParser, calculate_base_score
from libs.utils import ( from libs.utils import (
GlobalData, OutlinedText,
get_config, get_config,
get_current_ms, get_current_ms,
global_data,
load_all_textures_from_zip,
load_image_from_zip, load_image_from_zip,
load_texture_from_zip, load_texture_from_zip,
) )
class GameScreen: class GameScreen:
def __init__(self, width, height): def __init__(self, width: int, height: int):
self.width = width self.width = width
self.height = height self.height = height
self.judge_x = 414 self.judge_x = 414
@@ -25,25 +27,13 @@ class GameScreen:
self.song_is_started = False self.song_is_started = False
def load_textures(self): def load_textures(self):
self.textures = load_all_textures_from_zip('Graphics\\lumendata\\enso_system\\common.zip')
zip_file = 'Graphics\\lumendata\\enso_system\\common.zip' zip_file = 'Graphics\\lumendata\\enso_system\\common.zip'
self.texture_judge_circle = load_texture_from_zip(zip_file, 'lane_hit_img00017.png')
self.image_lane = load_image_from_zip(zip_file, 'lane_img00000.png') image = load_image_from_zip(zip_file, 'lane_img00000.png')
ray.image_resize(self.image_lane, 948, 176) ray.image_resize(image, 948, 176)
self.texture_lane = ray.load_texture_from_image(self.image_lane) ray.unload_texture(self.textures['lane'][0])
self.textures['lane'][0] = ray.load_texture_from_image(image)
self.texture_lane_cover = load_texture_from_zip(zip_file, 'lane_obi_img00000.png')
self.texture_score_cover = load_texture_from_zip(zip_file, 'lane_obi_img00003.png')
self.texture_don = [load_texture_from_zip(zip_file, 'onp_don_img00000.png'),
load_texture_from_zip(zip_file, 'onp_don_img00001.png')]
self.texture_kat = [load_texture_from_zip(zip_file, 'onp_katsu_img00000.png'),
load_texture_from_zip(zip_file, 'onp_katsu_img00001.png')]
self.texture_dai_don = [load_texture_from_zip(zip_file, 'onp_don_dai_img00000.png'),
load_texture_from_zip(zip_file, 'onp_don_dai_img00001.png')]
self.texture_dai_kat = [load_texture_from_zip(zip_file, 'onp_katsu_dai_img00000.png'),
load_texture_from_zip(zip_file, 'onp_katsu_dai_img00001.png')]
self.texture_balloon_head = [load_texture_from_zip(zip_file, 'onp_fusen_img00001.png'), self.texture_balloon_head = [load_texture_from_zip(zip_file, 'onp_fusen_img00001.png'),
load_texture_from_zip(zip_file, 'onp_fusen_img00002.png')] load_texture_from_zip(zip_file, 'onp_fusen_img00002.png')]
@@ -62,18 +52,12 @@ class GameScreen:
load_texture_from_zip(zip_file, 'onp_renda_dai_img00000.png')] load_texture_from_zip(zip_file, 'onp_renda_dai_img00000.png')]
self.texture_dai_drumroll_tail = [load_texture_from_zip(zip_file, 'onp_renda_dai_img00001.png'), self.texture_dai_drumroll_tail = [load_texture_from_zip(zip_file, 'onp_renda_dai_img00001.png'),
load_texture_from_zip(zip_file, 'onp_renda_dai_img00001.png')] load_texture_from_zip(zip_file, 'onp_renda_dai_img00001.png')]
self.texture_drumroll_count = load_texture_from_zip(zip_file, 'renda_num_img00000.png')
self.texture_drumroll_number = [] self.texture_drumroll_number = []
for i in range(1, 11): for i in range(1, 11):
filename = f'renda_num_img{str(i).zfill(5)}.png' filename = f'renda_num_img{str(i).zfill(5)}.png'
self.texture_drumroll_number.append(load_texture_from_zip(zip_file, filename)) self.texture_drumroll_number.append(load_texture_from_zip(zip_file, filename))
self.texture_barline = load_texture_from_zip(zip_file, 'lane_syousetsu_img00000.png')
self.texture_good = load_texture_from_zip(zip_file, 'lane_hit_effect_img00009.png') self.texture_good = load_texture_from_zip(zip_file, 'lane_hit_effect_img00009.png')
self.texture_good_hit_center = load_texture_from_zip(zip_file, 'lane_hit_img00019.png')
self.texture_good_hit_center_big = load_texture_from_zip(zip_file, 'lane_hit_img00021.png')
self.texture_good_hit_effect = [load_texture_from_zip(zip_file, 'lane_hit_effect_img00005.png'), self.texture_good_hit_effect = [load_texture_from_zip(zip_file, 'lane_hit_effect_img00005.png'),
load_texture_from_zip(zip_file, 'lane_hit_effect_img00006.png'), load_texture_from_zip(zip_file, 'lane_hit_effect_img00006.png'),
load_texture_from_zip(zip_file, 'lane_hit_effect_img00007.png'), load_texture_from_zip(zip_file, 'lane_hit_effect_img00007.png'),
@@ -99,25 +83,21 @@ class GameScreen:
load_texture_from_zip(zip_file, 'lane_hit_effect_img00019.png'), load_texture_from_zip(zip_file, 'lane_hit_effect_img00019.png'),
load_texture_from_zip(zip_file, 'lane_hit_effect_img00020.png')] load_texture_from_zip(zip_file, 'lane_hit_effect_img00020.png')]
self.texture_bad = load_texture_from_zip(zip_file, 'lane_hit_effect_img00010.png') image = load_image_from_zip(zip_file, 'lane_hit_img00005.png')
ray.image_resize(image, 951, 130)
self.image_lane_effect_good = load_image_from_zip(zip_file, 'lane_hit_img00007.png') ray.unload_texture(self.textures['lane_hit'][5])
ray.image_resize(self.image_lane_effect_good, 951, 130) self.textures['lane_hit'][5] = ray.load_texture_from_image(image)
self.image_lane_effect_don = load_image_from_zip(zip_file, 'lane_hit_img00005.png') image = load_image_from_zip(zip_file, 'lane_hit_img00006.png')
ray.image_resize(self.image_lane_effect_don, 951, 130) ray.image_resize(image, 951, 130)
self.image_lane_effect_kat = load_image_from_zip(zip_file, 'lane_hit_img00006.png') ray.unload_texture(self.textures['lane_hit'][6])
ray.image_resize(self.image_lane_effect_kat, 951, 130) self.textures['lane_hit'][6] = ray.load_texture_from_image(image)
self.texture_lane_effect_good = ray.load_texture_from_image(self.image_lane_effect_good) image = load_image_from_zip(zip_file, 'lane_hit_img00007.png')
self.texture_lane_effect_don = ray.load_texture_from_image(self.image_lane_effect_don) ray.image_resize(image, 951, 130)
self.texture_lane_effect_kat = ray.load_texture_from_image(self.image_lane_effect_kat) ray.unload_texture(self.textures['lane_hit'][7])
self.textures['lane_hit'][7] = ray.load_texture_from_image(image)
self.texture_drum = load_texture_from_zip(zip_file, 'lane_obi_img00014.png') self.texture_drum = load_texture_from_zip(zip_file, 'lane_obi_img00014.png')
self.texture_don_R = load_texture_from_zip(zip_file, 'lane_obi_img00015.png')
self.texture_don_L = load_texture_from_zip(zip_file, 'lane_obi_img00016.png')
self.texture_kat_R = load_texture_from_zip(zip_file, 'lane_obi_img00017.png')
self.texture_kat_L = load_texture_from_zip(zip_file, 'lane_obi_img00018.png')
self.texture_1p_emblem = load_texture_from_zip(zip_file, 'lane_obi_img00019.png')
self.texture_difficulty = [load_texture_from_zip(zip_file, 'lane_obi_img00021.png'), self.texture_difficulty = [load_texture_from_zip(zip_file, 'lane_obi_img00021.png'),
load_texture_from_zip(zip_file, 'lane_obi_img00022.png'), load_texture_from_zip(zip_file, 'lane_obi_img00022.png'),
load_texture_from_zip(zip_file, 'lane_obi_img00023.png'), load_texture_from_zip(zip_file, 'lane_obi_img00023.png'),
@@ -147,30 +127,8 @@ class GameScreen:
filename = 'onp_renda_moji_img00001.png' filename = 'onp_renda_moji_img00001.png'
self.texture_se_moji.append(load_texture_from_zip(zip_file, filename)) self.texture_se_moji.append(load_texture_from_zip(zip_file, filename))
zip_file = 'Graphics\\lumendata\\enso_system\\base1p.zip' self.textures.update(load_all_textures_from_zip('Graphics\\lumendata\\enso_system\\base1p.zip'))
self.texture_balloon_speech_bubble_p1 = load_texture_from_zip(zip_file, 'action_fusen_1p_img00000.png') self.textures.update(load_all_textures_from_zip('Graphics\\lumendata\\enso_system\\don1p.zip'))
self.texture_balloon = [load_texture_from_zip(zip_file, 'action_fusen_1p_img00011.png'),
load_texture_from_zip(zip_file, 'action_fusen_1p_img00012.png'),
load_texture_from_zip(zip_file, 'action_fusen_1p_img00013.png'),
load_texture_from_zip(zip_file, 'action_fusen_1p_img00014.png'),
load_texture_from_zip(zip_file, 'action_fusen_1p_img00015.png'),
load_texture_from_zip(zip_file, 'action_fusen_1p_img00016.png'),
load_texture_from_zip(zip_file, 'action_fusen_1p_img00017.png'),
load_texture_from_zip(zip_file, 'action_fusen_1p_img00018.png')]
self.texture_balloon_number = [load_texture_from_zip(zip_file, 'action_fusen_1p_img00001.png'),
load_texture_from_zip(zip_file, 'action_fusen_1p_img00002.png'),
load_texture_from_zip(zip_file, 'action_fusen_1p_img00003.png'),
load_texture_from_zip(zip_file, 'action_fusen_1p_img00004.png'),
load_texture_from_zip(zip_file, 'action_fusen_1p_img00005.png'),
load_texture_from_zip(zip_file, 'action_fusen_1p_img00006.png'),
load_texture_from_zip(zip_file, 'action_fusen_1p_img00007.png'),
load_texture_from_zip(zip_file, 'action_fusen_1p_img00008.png'),
load_texture_from_zip(zip_file, 'action_fusen_1p_img00009.png'),
load_texture_from_zip(zip_file, 'action_fusen_1p_img00010.png')]
self.texture_base_score_numbers = []
for i in range(0, 10):
filename = f'score_add_1p_img{str(i).zfill(5)}.png'
self.texture_base_score_numbers.append(load_texture_from_zip(zip_file, filename))
def load_sounds(self): def load_sounds(self):
self.sound_don = audio.load_sound('Sounds\\inst_00_don.wav') self.sound_don = audio.load_sound('Sounds\\inst_00_don.wav')
@@ -182,10 +140,10 @@ class GameScreen:
self.load_sounds() self.load_sounds()
#Map notes to textures #Map notes to textures
self.note_type_dict = {'1': self.texture_don, self.note_type_dict = {'1': self.textures['onp_don'],
'2': self.texture_kat, '2': self.textures['onp_katsu'],
'3': self.texture_dai_don, '3': self.textures['onp_don_dai'],
'4': self.texture_dai_kat, '4': self.textures['onp_katsu_dai'],
'5': self.texture_drumroll_head, '5': self.texture_drumroll_head,
'6': self.texture_dai_drumroll_head, '6': self.texture_dai_drumroll_head,
'7': self.texture_balloon_head, '7': self.texture_balloon_head,
@@ -207,14 +165,16 @@ class GameScreen:
def update(self): def update(self):
if GlobalData.start_song and not self.song_is_started: if global_data.start_song and not self.song_is_started:
self.init_tja(GlobalData.selected_song, GlobalData.selected_difficulty) self.init_tja(global_data.selected_song, global_data.selected_difficulty)
self.song_is_started = True self.song_is_started = True
self.current_ms = get_current_ms() - self.start_ms self.current_ms = get_current_ms() - self.start_ms
self.player_1.update(self) self.player_1.update(self)
if len(self.player_1.play_note_list) == 0 and not audio.is_sound_playing(self.song_music): if len(self.player_1.play_note_list) == 0 and not audio.is_sound_playing(self.song_music):
GlobalData.result_good, GlobalData.result_ok, GlobalData.result_bad, GlobalData.result_score = self.player_1.get_result_score() global_data.result_good, global_data.result_ok, global_data.result_bad, global_data.result_score = self.player_1.get_result_score()
GlobalData.start_song = False global_data.start_song = False
self.song_is_started = False self.song_is_started = False
return 'RESULT' return 'RESULT'
@@ -222,7 +182,7 @@ class GameScreen:
self.player_1.draw(self) self.player_1.draw(self)
class Player: class Player:
def __init__(self, game_screen, player_number: int, difficulty: int, judge_offset: int): def __init__(self, game_screen: GameScreen, player_number: int, difficulty: int, judge_offset: int):
self.timing_good = 25.0250015258789 self.timing_good = 25.0250015258789
self.timing_ok = 75.0750045776367 self.timing_ok = 75.0750045776367
self.timing_bad = 108.441665649414 self.timing_bad = 108.441665649414
@@ -258,38 +218,42 @@ class Player:
self.arc_points = 25 self.arc_points = 25
self.draw_judge_list = [] self.draw_judge_list: list[Judgement] = []
self.draw_effect_list = [] self.draw_effect_list: list[LaneHitEffect] = []
self.draw_arc_list = [] self.draw_arc_list: list[NoteArc] = []
self.draw_drum_hit_list = [] self.draw_drum_hit_list: list[DrumHitEffect] = []
self.drumroll_counter = [] self.drumroll_counter: list[DrumrollCounter] = []
self.balloon_list = [] self.balloon_list: list[BalloonAnimation] = []
self.combo_list = [] self.base_score_list: list[ScoreCounterAnimation] = []
self.score_list = [] self.combo_display = Combo(self.combo, game_screen.current_ms)
self.base_score_list = [] self.score_counter = ScoreCounter(self.score, game_screen.current_ms)
self.song_info = SongInfo(game_screen.current_ms, game_screen.tja.title, 'TEST')
self.input_log: dict[float, str] = dict()
def get_result_score(self): def get_result_score(self):
return self.good_count, self.ok_count, self.bad_count, self.score return self.good_count, self.ok_count, self.bad_count, self.score
def get_position(self, game_screen, ms, pixels_per_frame): def get_position(self, game_screen: GameScreen, ms: float, pixels_per_frame: float):
return int(game_screen.width + pixels_per_frame * 60 / 1000 * (ms - game_screen.current_ms + self.judge_offset) - 64) 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): def animation_manager(self, game_screen: GameScreen, animation_list: list):
if len(animation_list) <= 0: if len(animation_list) <= 0:
return return
for i in range(len(animation_list)-1, -1, -1): for i in range(len(animation_list)-1, -1, -1):
animation = animation_list[i] animation = animation_list[i]
animation.update(game_screen.current_ms) animation.update(game_screen.current_ms)
if animation.is_finished: if animation.is_finished:
animation_list.pop(i) animation_list.pop(i)
def bar_manager(self, game_screen): def bar_manager(self, game_screen: GameScreen):
#Add bar to current_bars list if it is ready to be shown on screen #Add bar to current_bars list if it is ready to be shown on screen
if len(self.draw_bar_list) > 0 and game_screen.current_ms > self.draw_bar_list[0]['load_ms']: if len(self.draw_bar_list) > 0 and game_screen.current_ms > self.draw_bar_list[0]['load_ms']:
self.current_bars.append(self.draw_bar_list.popleft()) self.current_bars.append(self.draw_bar_list.popleft())
#If a bar is off screen, remove it #If a bar is off screen, remove it
if len(self.current_bars) <= 0: if len(self.current_bars) == 0:
return return
for i in range(len(self.current_bars)-1, -1, -1): for i in range(len(self.current_bars)-1, -1, -1):
@@ -298,12 +262,12 @@ class Player:
if position < game_screen.judge_x + 650: if position < game_screen.judge_x + 650:
self.current_bars.pop(i) self.current_bars.pop(i)
def play_note_manager(self, game_screen): def play_note_manager(self, game_screen: GameScreen):
#Add note to current_notes list if it is ready to be shown on screen #Add note to current_notes list if it is ready to be shown on screen
if len(self.play_note_list) > 0 and game_screen.current_ms + 1000 >= self.play_note_list[0]['load_ms']: if len(self.play_note_list) > 0 and game_screen.current_ms + 1000 >= self.play_note_list[0]['load_ms']:
if self.play_note_list[0]['note'] == '8':
self.current_notes.append(self.play_note_list.popleft())
self.current_notes.append(self.play_note_list.popleft()) self.current_notes.append(self.play_note_list.popleft())
if len(self.play_note_list) > 0 and self.play_note_list[0]['note'] == '8':
self.current_notes.append(self.play_note_list.popleft())
#if a note was not hit within the window, remove it #if a note was not hit within the window, remove it
if len(self.current_notes) == 0: if len(self.current_notes) == 0:
@@ -328,7 +292,7 @@ class Player:
self.is_drumroll = False self.is_drumroll = False
self.is_balloon = False self.is_balloon = False
def draw_note_manager(self, game_screen): def draw_note_manager(self, game_screen: GameScreen):
if len(self.draw_note_list) > 0 and game_screen.current_ms + 1000 >= self.draw_note_list[0]['load_ms']: if len(self.draw_note_list) > 0 and game_screen.current_ms + 1000 >= self.draw_note_list[0]['load_ms']:
if self.draw_note_list[0]['note'] in {'5', '6', '7'}: if self.draw_note_list[0]['note'] in {'5', '6', '7'}:
while self.draw_note_list[0]['note'] != '8': while self.draw_note_list[0]['note'] != '8':
@@ -345,7 +309,7 @@ class Player:
self.current_notes_draw[0]['color'] += 1 self.current_notes_draw[0]['color'] += 1
note = self.current_notes_draw[0] note = self.current_notes_draw[0]
if note['note'] in {'5', '6', '7'}: if note['note'] in {'5', '6', '7'} and len(self.current_notes_draw) > 1:
note = self.current_notes_draw[1] note = self.current_notes_draw[1]
position = self.get_position(game_screen, note['ms'], note['ppf']) position = self.get_position(game_screen, note['ms'], note['ppf'])
if position < game_screen.judge_x + 650: if position < game_screen.judge_x + 650:
@@ -353,12 +317,12 @@ class Player:
self.current_notes_draw.pop(0) self.current_notes_draw.pop(0)
self.current_notes_draw.pop(0) self.current_notes_draw.pop(0)
def note_manager(self, game_screen): def note_manager(self, game_screen: GameScreen):
self.bar_manager(game_screen) self.bar_manager(game_screen)
self.play_note_manager(game_screen) self.play_note_manager(game_screen)
self.draw_note_manager(game_screen) self.draw_note_manager(game_screen)
def note_correct(self, game_screen, note): def note_correct(self, game_screen: GameScreen, note: dict):
index = note['index'] index = note['index']
if note['note'] == '8': if note['note'] == '8':
note_type = game_screen.note_type_dict['3'] note_type = game_screen.note_type_dict['3']
@@ -376,19 +340,16 @@ class Player:
index = self.current_notes_draw.index(note) index = self.current_notes_draw.index(note)
self.current_notes_draw.pop(index) self.current_notes_draw.pop(index)
def check_drumroll(self, game_screen, drum_type): def check_drumroll(self, game_screen: GameScreen, drum_type: str):
note_type = game_screen.note_type_dict[str(int(drum_type)+self.drumroll_big)] 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.draw_arc_list.append(NoteArc(note_type, game_screen.current_ms, self.player_number))
self.curr_drumroll_count += 1 self.curr_drumroll_count += 1
self.score += 100 self.score += 100
self.base_score_list.append(ScoreCounterAnimation(game_screen.current_ms, 100)) self.base_score_list.append(ScoreCounterAnimation(game_screen.current_ms, 100))
color = 255 - (self.curr_drumroll_count*10) color = max(0, 255 - (self.curr_drumroll_count * 10))
if color < 0: self.current_notes_draw[0]['color'] = color
self.current_notes_draw[0]['color'] = 0
else:
self.current_notes_draw[0]['color'] = color
def check_balloon(self, game_screen, drum_type): def check_balloon(self, game_screen: GameScreen, drum_type: str):
current_note = self.current_notes[0] current_note = self.current_notes[0]
if current_note['note'] == '7': if current_note['note'] == '7':
current_note = self.current_notes[1] current_note = self.current_notes[1]
@@ -403,8 +364,10 @@ class Player:
self.current_notes_draw[0]['popped'] = True self.current_notes_draw[0]['popped'] = True
audio.play_sound(game_screen.sound_balloon_pop) audio.play_sound(game_screen.sound_balloon_pop)
self.note_correct(game_screen, self.current_notes[0]) self.note_correct(game_screen, self.current_notes[0])
if len(self.current_notes) > 1 and self.current_notes[0]['note'] == '8':
self.note_correct(game_screen, self.current_notes[0])
def check_note(self, game_screen, drum_type): def check_note(self, game_screen: GameScreen, drum_type: str):
if self.is_drumroll: if self.is_drumroll:
self.check_drumroll(game_screen, drum_type) self.check_drumroll(game_screen, drum_type)
elif self.is_balloon and drum_type == '1': elif self.is_balloon and drum_type == '1':
@@ -412,12 +375,12 @@ class Player:
elif len(self.current_notes) != 0: elif len(self.current_notes) != 0:
self.curr_drumroll_count = 0 self.curr_drumroll_count = 0
self.curr_balloon_count = 0 self.curr_balloon_count = 0
current_note = self.current_notes[0] current_note = next(
#Fix later (note for note in self.current_notes if note['note'] not in {'5', '6', '7', '8'}),
i = 0 None # Default if no matching note is found
while current_note['note'] in {'5', '6', '7', '8'}: )
i += 1 if current_note is None:
current_note = self.current_notes[i] return
note_type = current_note['note'] note_type = current_note['note']
note_ms = current_note['ms'] note_ms = current_note['ms']
#If the wrong key was hit, stop checking #If the wrong key was hit, stop checking
@@ -454,7 +417,7 @@ class Player:
self.combo = 0 self.combo = 0
self.current_notes.popleft() self.current_notes.popleft()
def drumroll_counter_manager(self, game_screen): def drumroll_counter_manager(self, game_screen: GameScreen):
if self.is_drumroll and self.curr_drumroll_count > 0: if self.is_drumroll and self.curr_drumroll_count > 0:
if len(self.drumroll_counter) == 0 or self.drumroll_counter[-1].is_finished: if len(self.drumroll_counter) == 0 or self.drumroll_counter[-1].is_finished:
self.drumroll_counter.append(DrumrollCounter(game_screen.current_ms)) self.drumroll_counter.append(DrumrollCounter(game_screen.current_ms))
@@ -467,7 +430,7 @@ class Player:
else: else:
self.drumroll_counter[0].update(game_screen, game_screen.current_ms, self.curr_drumroll_count) self.drumroll_counter[0].update(game_screen, game_screen.current_ms, self.curr_drumroll_count)
def balloon_animation_manager(self, game_screen): def balloon_animation_manager(self, game_screen: GameScreen):
if len(self.balloon_list) <= 0: if len(self.balloon_list) <= 0:
return return
@@ -479,49 +442,43 @@ class Player:
else: else:
self.balloon_list[0].update(game_screen, game_screen.current_ms, self.curr_balloon_count, True) self.balloon_list[0].update(game_screen, game_screen.current_ms, self.curr_balloon_count, True)
def combo_manager(self, game_screen): def key_manager(self, game_screen: GameScreen):
if self.combo >= 3 and len(self.combo_list) == 0: left_kats = get_config()["keybinds"]["left_kat"]
self.combo_list.append(Combo(self.combo, game_screen.current_ms)) left_dons = get_config()["keybinds"]["left_don"]
elif self.combo < 3 and len(self.combo_list) != 0: right_dons = get_config()["keybinds"]["right_don"]
self.combo_list.pop(0) right_kats = get_config()["keybinds"]["right_kat"]
elif len(self.combo_list) == 1: for left_don in left_dons:
self.combo_list[0].update(game_screen, game_screen.current_ms, self.combo) if ray.is_key_pressed(ord(left_don)):
self.draw_effect_list.append(LaneHitEffect(game_screen.current_ms, 'DON'))
self.draw_drum_hit_list.append(DrumHitEffect(game_screen.current_ms, 'DON', 'L'))
audio.play_sound(game_screen.sound_don)
self.check_note(game_screen, '1')
self.input_log[game_screen.current_ms] = 'DON'
for right_don in right_dons:
if ray.is_key_pressed(ord(right_don)):
self.draw_effect_list.append(LaneHitEffect(game_screen.current_ms, 'DON'))
self.draw_drum_hit_list.append(DrumHitEffect(game_screen.current_ms, 'DON', 'R'))
audio.play_sound(game_screen.sound_don)
self.check_note(game_screen, '1')
self.input_log[game_screen.current_ms] = 'DON'
for left_kat in left_kats:
if ray.is_key_pressed(ord(left_kat)):
self.draw_effect_list.append(LaneHitEffect(game_screen.current_ms, 'KAT'))
self.draw_drum_hit_list.append(DrumHitEffect(game_screen.current_ms, 'KAT', 'L'))
audio.play_sound(game_screen.sound_kat)
self.check_note(game_screen, '2')
self.input_log[game_screen.current_ms] = 'KAT'
for right_kat in right_kats:
if ray.is_key_pressed(ord(right_kat)):
self.draw_effect_list.append(LaneHitEffect(game_screen.current_ms, 'KAT'))
self.draw_drum_hit_list.append(DrumHitEffect(game_screen.current_ms, 'KAT', 'R'))
audio.play_sound(game_screen.sound_kat)
self.check_note(game_screen, '2')
self.input_log[game_screen.current_ms] = 'KAT'
def score_manager(self, game_screen): def update(self, game_screen: GameScreen):
if len(self.score_list) == 0:
self.score_list.append(ScoreCounter(self.score, game_screen.current_ms))
elif len(self.score_list) == 1:
self.score_list[0].update(game_screen.current_ms, self.score)
def key_manager(self, game_screen):
left_kat = ord(get_config()["keybinds"]["left_kat"])
left_don = ord(get_config()["keybinds"]["left_don"])
right_don = ord(get_config()["keybinds"]["right_don"])
right_kat = ord(get_config()["keybinds"]["right_kat"])
if ray.is_key_pressed(left_don):
self.draw_effect_list.append(LaneHitEffect(game_screen.current_ms, 'DON'))
self.draw_drum_hit_list.append(DrumHitEffect(game_screen.current_ms, 'DON', 'L'))
audio.play_sound(game_screen.sound_don)
self.check_note(game_screen, '1')
if ray.is_key_pressed(right_don):
self.draw_effect_list.append(LaneHitEffect(game_screen.current_ms, 'DON'))
self.draw_drum_hit_list.append(DrumHitEffect(game_screen.current_ms, 'DON', 'R'))
audio.play_sound(game_screen.sound_don)
self.check_note(game_screen, '1')
if ray.is_key_pressed(left_kat):
self.draw_effect_list.append(LaneHitEffect(game_screen.current_ms, 'KAT'))
self.draw_drum_hit_list.append(DrumHitEffect(game_screen.current_ms, 'KAT', 'L'))
audio.play_sound(game_screen.sound_kat)
self.check_note(game_screen, '2')
if ray.is_key_pressed(right_kat):
self.draw_effect_list.append(LaneHitEffect(game_screen.current_ms, 'KAT'))
self.draw_drum_hit_list.append(DrumHitEffect(game_screen.current_ms, 'KAT', 'R'))
audio.play_sound(game_screen.sound_kat)
self.check_note(game_screen, '2')
def update(self, game_screen):
self.note_manager(game_screen) self.note_manager(game_screen)
self.combo_manager(game_screen) self.combo_display.update(game_screen, game_screen.current_ms, self.combo)
self.drumroll_counter_manager(game_screen) self.drumroll_counter_manager(game_screen)
self.balloon_animation_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_judge_list)
@@ -529,20 +486,20 @@ class Player:
self.animation_manager(game_screen, self.draw_drum_hit_list) self.animation_manager(game_screen, self.draw_drum_hit_list)
self.animation_manager(game_screen, self.draw_arc_list) self.animation_manager(game_screen, self.draw_arc_list)
self.animation_manager(game_screen, self.base_score_list) self.animation_manager(game_screen, self.base_score_list)
self.score_manager(game_screen) self.song_info.update(game_screen.current_ms)
self.score_counter.update(game_screen.current_ms, self.score)
self.key_manager(game_screen) self.key_manager(game_screen)
def draw_animation_list(self, game_screen, animation_list): def draw_animation_list(self, game_screen: GameScreen, animation_list: list):
for animation in animation_list: for animation in animation_list:
animation.draw(game_screen) animation.draw(game_screen)
def draw_drumroll(self, game_screen, big, position, index, color): def draw_drumroll(self, game_screen: GameScreen, big: bool, position: int, index: int, color: int):
drumroll_start_position = position drumroll_start_position = position
tail = self.current_notes_draw[index+1] i = 1
i = 0 while self.current_notes_draw[index+i]['note'] != '8':
while tail['note'] != '8':
i += 1 i += 1
tail = self.current_notes_draw[index+i] tail = self.current_notes_draw[index+i]
if big: if big:
drumroll_body = 'dai_drumroll_body' drumroll_body = 'dai_drumroll_body'
drumroll_tail = 'dai_drumroll_tail' drumroll_tail = 'dai_drumroll_tail'
@@ -554,14 +511,13 @@ class Player:
self.draw_note(game_screen, drumroll_body, (drumroll_start_position+64), color, 8, drumroll_length=length) self.draw_note(game_screen, drumroll_body, (drumroll_start_position+64), color, 8, drumroll_length=length)
self.draw_note(game_screen, drumroll_tail, drumroll_end_position, color, 10, drumroll_length=None) self.draw_note(game_screen, drumroll_tail, drumroll_end_position, color, 10, drumroll_length=None)
def draw_balloon(self, game_screen, note, position, index): def draw_balloon(self, game_screen: GameScreen, note: dict, position: int, index: int):
if self.current_notes_draw[0].get('popped', None): if self.current_notes_draw[0].get('popped', None):
return return
end_time = self.current_notes_draw[index+1] i = 1
i = 0 while self.current_notes_draw[index+i]['note'] != '8':
while end_time['note'] != '8':
i += 1 i += 1
end_time = self.current_notes_draw[index+i] end_time = self.current_notes_draw[index+i]
end_time_position = self.get_position(game_screen, end_time['load_ms'], end_time['ppf']) end_time_position = self.get_position(game_screen, end_time['load_ms'], end_time['ppf'])
if game_screen.current_ms >= end_time['ms']: if game_screen.current_ms >= end_time['ms']:
position = end_time_position position = end_time_position
@@ -569,11 +525,11 @@ class Player:
position = 349 position = 349
self.draw_note(game_screen, '7', position, 255, 9) self.draw_note(game_screen, '7', position, 255, 9)
def draw_note(self, game_screen, note, position, color, se_note, drumroll_length=None): def draw_note(self, game_screen: GameScreen, note: str, position: int, color: int, se_note: int | None, drumroll_length: int | None=None):
note_padding = 64 note_padding = 64
if note == 'barline': if note == 'barline':
y = 184 y = 184
ray.draw_texture(game_screen.texture_barline, position+note_padding-4, y+6, ray.WHITE) ray.draw_texture(game_screen.textures['lane_syousetsu'][0], position+note_padding-4, y+6, ray.WHITE)
return return
if note not in game_screen.note_type_dict: if note not in game_screen.note_type_dict:
return return
@@ -610,7 +566,7 @@ class Player:
dest_rect = ray.Rectangle(position-offset - (game_screen.texture_se_moji[se_note].width // 2) + 64, 323, drumroll_length,game_screen.texture_se_moji[se_note].height) dest_rect = ray.Rectangle(position-offset - (game_screen.texture_se_moji[se_note].width // 2) + 64, 323, drumroll_length,game_screen.texture_se_moji[se_note].height)
ray.draw_texture_pro(game_screen.texture_se_moji[se_note], source_rect, dest_rect, ray.Vector2(0,0), 0, ray.WHITE) ray.draw_texture_pro(game_screen.texture_se_moji[se_note], source_rect, dest_rect, ray.Vector2(0,0), 0, ray.WHITE)
def draw_bars(self, game_screen): def draw_bars(self, game_screen: GameScreen):
if len(self.current_bars) <= 0: if len(self.current_bars) <= 0:
return return
@@ -620,7 +576,7 @@ class Player:
position = self.get_position(game_screen, load_ms, pixels_per_frame) position = self.get_position(game_screen, load_ms, pixels_per_frame)
self.draw_note(game_screen, 'barline', position, 255, None) self.draw_note(game_screen, 'barline', position, 255, None)
def draw_notes(self, game_screen): def draw_notes(self, game_screen: GameScreen):
if len(self.current_notes_draw) <= 0: if len(self.current_notes_draw) <= 0:
return return
@@ -640,28 +596,37 @@ class Player:
self.draw_note(game_screen, note_type, position, 255, note['se_note']) self.draw_note(game_screen, note_type, position, 255, note['se_note'])
#ray.draw_text(str(i), position+64, 192, 25, ray.GREEN) #ray.draw_text(str(i), position+64, 192, 25, ray.GREEN)
def draw(self, game_screen): def draw_gauge(self, game_screen: GameScreen):
ray.draw_texture(game_screen.texture_lane, 332, 184, ray.WHITE) ray.draw_texture(game_screen.textures['gage_don_1p_hard'][0], 327, 128, ray.WHITE)
ray.draw_texture(game_screen.textures['gage_don_1p_hard'][1], 483, 124, ray.WHITE)
ray.draw_texture(game_screen.textures['gage_don_1p_hard'][10], 483, 124, ray.fade(ray.WHITE, 0.15))
ray.draw_texture(game_screen.textures['gage_don_1p_hard'][11], 1038, 141, ray.WHITE)
ray.draw_texture(game_screen.textures['gage_don_1p_hard'][12], 1187, 130, ray.WHITE)
def draw(self, game_screen: GameScreen):
ray.draw_texture(game_screen.textures['lane'][0], 332, 184, ray.WHITE)
self.draw_gauge(game_screen)
self.draw_animation_list(game_screen, self.draw_effect_list) self.draw_animation_list(game_screen, self.draw_effect_list)
ray.draw_texture(game_screen.texture_judge_circle, 342, 184, ray.WHITE) ray.draw_texture(game_screen.textures['lane_hit'][17], 342, 184, ray.WHITE)
self.draw_animation_list(game_screen, self.draw_judge_list) self.draw_animation_list(game_screen, self.draw_judge_list)
self.draw_bars(game_screen) self.draw_bars(game_screen)
self.draw_notes(game_screen) self.draw_notes(game_screen)
ray.draw_texture(game_screen.texture_lane_cover, 0, 184, ray.WHITE) ray.draw_texture(game_screen.textures['lane_obi'][0], 0, 184, ray.WHITE)
ray.draw_texture(game_screen.texture_drum, 211, 206, 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.draw_drum_hit_list)
self.draw_animation_list(game_screen, self.combo_list) self.combo_display.draw(game_screen)
ray.draw_texture(game_screen.texture_score_cover, 0, 184, ray.WHITE) ray.draw_texture(game_screen.textures['lane_obi'][3], 0, 184, ray.WHITE)
ray.draw_texture(game_screen.texture_1p_emblem, 0, 225, ray.WHITE) ray.draw_texture(game_screen.textures['lane_obi'][19], 0, 225, ray.WHITE)
ray.draw_texture(game_screen.texture_difficulty[self.difficulty], 50, 222, ray.WHITE) ray.draw_texture(game_screen.texture_difficulty[self.difficulty], 50, 222, ray.WHITE)
self.song_info.draw(game_screen)
self.draw_animation_list(game_screen, self.drumroll_counter) 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.draw_arc_list)
self.draw_animation_list(game_screen, self.balloon_list) self.draw_animation_list(game_screen, self.balloon_list)
self.draw_animation_list(game_screen, self.score_list) self.score_counter.draw(game_screen)
self.draw_animation_list(game_screen, self.base_score_list) self.draw_animation_list(game_screen, self.base_score_list)
class Judgement: class Judgement:
def __init__(self, current_ms, type, big): def __init__(self, current_ms: float, type: str, big: bool):
self.type = type self.type = type
self.big = big self.big = big
self.is_finished = False self.is_finished = False
@@ -680,7 +645,7 @@ class Judgement:
self.texture_animation = Animation(current_ms, 100, 'texture_change') self.texture_animation = Animation(current_ms, 100, 'texture_change')
self.texture_animation.params['textures'] = [(33, 50, 1), (50, 83, 2), (83, 100, 3), (100, float('inf'), 4)] self.texture_animation.params['textures'] = [(33, 50, 1), (50, 83, 2), (83, 100, 3), (100, float('inf'), 4)]
def update(self, current_ms): def update(self, current_ms: float):
self.fade_animation_1.update(current_ms) self.fade_animation_1.update(current_ms)
self.fade_animation_2.update(current_ms) self.fade_animation_2.update(current_ms)
self.move_animation.update(current_ms) self.move_animation.update(current_ms)
@@ -689,17 +654,17 @@ class Judgement:
if self.fade_animation_2.is_finished: if self.fade_animation_2.is_finished:
self.is_finished = True self.is_finished = True
def draw(self, game_screen): def draw(self, game_screen: GameScreen):
y = self.move_animation.attribute y = self.move_animation.attribute
index = self.texture_animation.attribute index = int(self.texture_animation.attribute)
hit_color = ray.fade(ray.WHITE, self.fade_animation_1.attribute) hit_color = ray.fade(ray.WHITE, self.fade_animation_1.attribute)
color = ray.fade(ray.WHITE, self.fade_animation_2.attribute) color = ray.fade(ray.WHITE, self.fade_animation_2.attribute)
if self.type == 'GOOD': if self.type == 'GOOD':
if self.big: if self.big:
ray.draw_texture(game_screen.texture_good_hit_center_big, 342, 184, color) ray.draw_texture(game_screen.textures['lane_hit'][21], 342, 184, color)
ray.draw_texture(game_screen.texture_good_hit_effect_big[index], 304, 143, hit_color) ray.draw_texture(game_screen.texture_good_hit_effect_big[index], 304, 143, hit_color)
else: else:
ray.draw_texture(game_screen.texture_good_hit_center, 342, 184, color) ray.draw_texture(game_screen.textures['lane_hit'][19], 342, 184, color)
ray.draw_texture(game_screen.texture_good_hit_effect[index], 304, 143, hit_color) ray.draw_texture(game_screen.texture_good_hit_effect[index], 304, 143, hit_color)
ray.draw_texture(game_screen.texture_good, 370, int(y), color) ray.draw_texture(game_screen.texture_good, 370, int(y), color)
elif self.type == 'OK': elif self.type == 'OK':
@@ -711,10 +676,10 @@ class Judgement:
ray.draw_texture(game_screen.texture_ok_hit_effect[index], 304, 143, hit_color) ray.draw_texture(game_screen.texture_ok_hit_effect[index], 304, 143, hit_color)
ray.draw_texture(game_screen.texture_ok, 370, int(y), color) ray.draw_texture(game_screen.texture_ok, 370, int(y), color)
elif self.type == 'BAD': elif self.type == 'BAD':
ray.draw_texture(game_screen.texture_bad, 370, int(y), color) ray.draw_texture(game_screen.textures['lane_hit_effect'][10], 370, int(y), color)
class LaneHitEffect: class LaneHitEffect:
def __init__(self, current_ms, type): def __init__(self, current_ms: float, type: str):
self.type = type self.type = type
self.color = ray.fade(ray.WHITE, 0.5) self.color = ray.fade(ray.WHITE, 0.5)
self.animation = Animation(current_ms, 150, 'fade') self.animation = Animation(current_ms, 150, 'fade')
@@ -722,23 +687,23 @@ class LaneHitEffect:
self.animation.params['initial_opacity'] = 0.5 self.animation.params['initial_opacity'] = 0.5
self.is_finished = False self.is_finished = False
def update(self, current_ms): def update(self, current_ms: float):
self.animation.update(current_ms) self.animation.update(current_ms)
fade_opacity = self.animation.attribute fade_opacity = self.animation.attribute
self.color = ray.fade(ray.WHITE, fade_opacity) self.color = ray.fade(ray.WHITE, fade_opacity)
if self.animation.is_finished: if self.animation.is_finished:
self.is_finished = True self.is_finished = True
def draw(self, game_screen): def draw(self, game_screen: GameScreen):
if self.type == 'GOOD': if self.type == 'GOOD':
ray.draw_texture(game_screen.texture_lane_effect_good, 328, 192, self.color) ray.draw_texture(game_screen.textures['lane_hit'][7], 328, 192, self.color)
elif self.type == 'DON': elif self.type == 'DON':
ray.draw_texture(game_screen.texture_lane_effect_don, 328, 192, self.color) ray.draw_texture(game_screen.textures['lane_hit'][5], 328, 192, self.color)
elif self.type == 'KAT': elif self.type == 'KAT':
ray.draw_texture(game_screen.texture_lane_effect_kat, 328, 192, self.color) ray.draw_texture(game_screen.textures['lane_hit'][6], 328, 192, self.color)
class DrumHitEffect: class DrumHitEffect:
def __init__(self, current_ms, type, side): def __init__(self, current_ms: float, type: str, side: str):
self.type = type self.type = type
self.side = side self.side = side
self.color = ray.fade(ray.WHITE, 1) self.color = ray.fade(ray.WHITE, 1)
@@ -746,7 +711,7 @@ class DrumHitEffect:
self.animation = Animation(current_ms, 100, 'fade') self.animation = Animation(current_ms, 100, 'fade')
self.animation.params['delay'] = 67 self.animation.params['delay'] = 67
def update(self, current_ms): def update(self, current_ms: float):
self.animation.update(current_ms) self.animation.update(current_ms)
fade_opacity = self.animation.attribute fade_opacity = self.animation.attribute
self.color = ray.fade(ray.WHITE, fade_opacity) self.color = ray.fade(ray.WHITE, fade_opacity)
@@ -757,17 +722,17 @@ class DrumHitEffect:
x, y = 211, 206 x, y = 211, 206
if self.type == 'DON': if self.type == 'DON':
if self.side == 'L': if self.side == 'L':
ray.draw_texture(game_screen.texture_don_L, x, y, self.color) ray.draw_texture(game_screen.textures['lane_obi'][16], x, y, self.color)
elif self.side == 'R': elif self.side == 'R':
ray.draw_texture(game_screen.texture_don_R, x, y, self.color) ray.draw_texture(game_screen.textures['lane_obi'][15], x, y, self.color)
elif self.type == 'KAT': elif self.type == 'KAT':
if self.side == 'L': if self.side == 'L':
ray.draw_texture(game_screen.texture_kat_L, x, y, self.color) ray.draw_texture(game_screen.textures['lane_obi'][18], x, y, self.color)
elif self.side == 'R': elif self.side == 'R':
ray.draw_texture(game_screen.texture_kat_R, x, y, self.color) ray.draw_texture(game_screen.textures['lane_obi'][17], x, y, self.color)
class NoteArc: class NoteArc:
def __init__(self, note_type, current_ms, player_number): def __init__(self, note_type: list, current_ms: float, player_number: int):
self.note_type = note_type self.note_type = note_type
self.arc_points = 25 self.arc_points = 25
self.create_ms = current_ms self.create_ms = current_ms
@@ -776,7 +741,7 @@ class NoteArc:
self.y_i = 168 self.y_i = 168
self.is_finished = False self.is_finished = False
def update(self, current_ms): def update(self, current_ms: float):
if self.x_i >= 1150: if self.x_i >= 1150:
self.is_finished = True self.is_finished = True
radius = 414 radius = 414
@@ -808,7 +773,7 @@ class NoteArc:
ray.draw_texture(self.note_type[current_eighth % 2], int(self.x_i), int(self.y_i), ray.WHITE) ray.draw_texture(self.note_type[current_eighth % 2], int(self.x_i), int(self.y_i), ray.WHITE)
class DrumrollCounter: class DrumrollCounter:
def __init__(self, current_ms): def __init__(self, current_ms: float):
self.create_ms = current_ms self.create_ms = current_ms
self.is_finished = False self.is_finished = False
self.total_duration = 1349 self.total_duration = 1349
@@ -817,13 +782,13 @@ class DrumrollCounter:
self.fade_animation.params['delay'] = self.total_duration - 166 self.fade_animation.params['delay'] = self.total_duration - 166
self.stretch_animation = Animation(current_ms, 0, 'text_stretch') self.stretch_animation = Animation(current_ms, 0, 'text_stretch')
def update_count(self, current_ms, count, elapsed_time): def update_count(self, current_ms: float, count: int, elapsed_time: float):
self.total_duration = elapsed_time + 1349 self.total_duration = elapsed_time + 1349
if self.drumroll_count != count: if self.drumroll_count != count:
self.drumroll_count = count self.drumroll_count = count
self.stretch_animation = Animation(current_ms, 50, 'text_stretch') self.stretch_animation = Animation(current_ms, 50, 'text_stretch')
def update(self, game_screen, current_ms, drumroll_count): def update(self, game_screen: GameScreen, current_ms: float, drumroll_count: int):
self.stretch_animation.update(current_ms) self.stretch_animation.update(current_ms)
self.fade_animation.update(current_ms) self.fade_animation.update(current_ms)
@@ -833,19 +798,19 @@ class DrumrollCounter:
if self.fade_animation.is_finished: if self.fade_animation.is_finished:
self.is_finished = True self.is_finished = True
def draw(self, game_screen): def draw(self, game_screen: GameScreen):
color = ray.fade(ray.WHITE, self.fade_animation.attribute) color = ray.fade(ray.WHITE, self.fade_animation.attribute)
ray.draw_texture(game_screen.texture_drumroll_count, 200, 0, color) ray.draw_texture(game_screen.textures['renda_num'][0], 200, 0, color)
counter = str(self.drumroll_count) counter = str(self.drumroll_count)
total_width = len(counter) * 52 total_width = len(counter) * 52
start_x = 344 - (total_width // 2) 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) 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)): for i in range(len(counter)):
dest_rect = ray.Rectangle(start_x + (i * 52), 50 - self.stretch_animation.attribute, game_screen.texture_drumroll_number[0].width, game_screen.texture_drumroll_number[0].height + self.stretch_animation.attribute) dest_rect = ray.Rectangle(start_x + (i * 52), 50 - self.stretch_animation.attribute, game_screen.texture_drumroll_number[0].width, game_screen.texture_drumroll_number[0].height + self.stretch_animation.attribute)
ray.draw_texture_pro(game_screen.texture_balloon_number[int(counter[i])], source_rect, dest_rect, ray.Vector2(0,0), 0, color) ray.draw_texture_pro(game_screen.textures['action_fusen_1p'][int(counter[i])+1], source_rect, dest_rect, ray.Vector2(0,0), 0, color)
class BalloonAnimation: class BalloonAnimation:
def __init__(self, current_ms, balloon_total): def __init__(self, current_ms: float, balloon_total: int):
self.create_ms = current_ms self.create_ms = current_ms
self.is_finished = False self.is_finished = False
self.total_duration = 83.33 self.total_duration = 83.33
@@ -856,12 +821,12 @@ class BalloonAnimation:
self.fade_animation = Animation(current_ms, 166, 'fade') self.fade_animation = Animation(current_ms, 166, 'fade')
self.stretch_animation = Animation(current_ms, 0, 'text_stretch') self.stretch_animation = Animation(current_ms, 0, 'text_stretch')
def update_count(self, current_ms, balloon_count): def update_count(self, current_ms: float, balloon_count: int):
if self.balloon_count != balloon_count: if self.balloon_count != balloon_count:
self.balloon_count = balloon_count self.balloon_count = balloon_count
self.stretch_animation = Animation(current_ms, 50, 'text_stretch') self.stretch_animation = Animation(current_ms, 50, 'text_stretch')
def update(self, game_screen, current_ms, balloon_count, is_popped): def update(self, game_screen: GameScreen, current_ms: float, balloon_count: int, is_popped: bool):
self.update_count(current_ms, balloon_count) self.update_count(current_ms, balloon_count)
self.stretch_animation.update(current_ms) self.stretch_animation.update(current_ms)
self.is_popped = is_popped self.is_popped = is_popped
@@ -876,26 +841,26 @@ class BalloonAnimation:
if self.fade_animation.is_finished: if self.fade_animation.is_finished:
self.is_finished = True self.is_finished = True
def draw(self, game_screen): def draw(self, game_screen: GameScreen):
if self.is_popped: if self.is_popped:
ray.draw_texture(game_screen.texture_balloon[7], 460, 130, self.color) ray.draw_texture(game_screen.textures['action_fusen_1p'][18], 460, 130, self.color)
elif self.balloon_count >= 1: elif self.balloon_count >= 1:
balloon_index = (self.balloon_count - 1) * 7 // self.balloon_total balloon_index = (self.balloon_count - 1) * 7 // self.balloon_total + 11
ray.draw_texture(game_screen.texture_balloon[balloon_index], 460, 130, self.color) ray.draw_texture(game_screen.textures['action_fusen_1p'][balloon_index], 460, 130, self.color)
if self.balloon_count > 0: if self.balloon_count > 0:
ray.draw_texture(game_screen.texture_balloon_speech_bubble_p1, 414, 40, ray.WHITE) ray.draw_texture(game_screen.textures['action_fusen_1p'][0], 414, 40, ray.WHITE)
counter = str(self.balloon_total - self.balloon_count + 1) counter = str(self.balloon_total - self.balloon_count + 1)
x, y = 493, 68 x, y = 493, 68
margin = 52 margin = 52
total_width = len(counter) * margin total_width = len(counter) * margin
start_x = x - (total_width // 2) 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) source_rect = ray.Rectangle(0, 0, game_screen.textures['action_fusen_1p'][1].width, game_screen.textures['action_fusen_1p'][1].height)
for i in range(len(counter)): for i in range(len(counter)):
dest_rect = ray.Rectangle(start_x + (i * margin), y - self.stretch_animation.attribute, game_screen.texture_balloon_number[0].width, game_screen.texture_balloon_number[0].height + self.stretch_animation.attribute) dest_rect = ray.Rectangle(start_x + (i * margin), y - self.stretch_animation.attribute, game_screen.textures['action_fusen_1p'][1].width, game_screen.textures['action_fusen_1p'][1].height + self.stretch_animation.attribute)
ray.draw_texture_pro(game_screen.texture_balloon_number[int(counter[i])], source_rect, dest_rect, ray.Vector2(0,0), 0, self.color) ray.draw_texture_pro(game_screen.textures['action_fusen_1p'][int(counter[i])+1], source_rect, dest_rect, ray.Vector2(0,0), 0, self.color)
class Combo: class Combo:
def __init__(self, combo, current_ms): def __init__(self, combo: int, current_ms: float):
self.combo = combo self.combo = combo
self.stretch_animation = Animation(current_ms, 0, 'text_stretch') self.stretch_animation = Animation(current_ms, 0, 'text_stretch')
self.color = [ray.fade(ray.WHITE, 1), ray.fade(ray.WHITE, 1), ray.fade(ray.WHITE, 1)] self.color = [ray.fade(ray.WHITE, 1), ray.fade(ray.WHITE, 1), ray.fade(ray.WHITE, 1)]
@@ -908,12 +873,12 @@ class Combo:
current_ms + (4 / 3) * self.cycle_time current_ms + (4 / 3) * self.cycle_time
] ]
def update_count(self, current_ms, combo): def update_count(self, current_ms: float, combo: int):
if self.combo != combo: if self.combo != combo:
self.combo = combo self.combo = combo
self.stretch_animation = Animation(current_ms, 50, 'text_stretch') self.stretch_animation = Animation(current_ms, 50, 'text_stretch')
def update(self, game_screen, current_ms, combo): def update(self, game_screen: GameScreen, current_ms: float, combo: int):
self.update_count(current_ms, combo) self.update_count(current_ms, combo)
self.stretch_animation.update(current_ms) self.stretch_animation.update(current_ms)
@@ -935,7 +900,9 @@ class Combo:
fade = 0 fade = 0
self.color[i] = ray.fade(ray.WHITE, fade) self.color[i] = ray.fade(ray.WHITE, fade)
def draw(self, game_screen): def draw(self, game_screen: GameScreen):
if self.combo < 3:
return
if self.combo < 100: if self.combo < 100:
text_color = 0 text_color = 0
margin = 30 margin = 30
@@ -958,21 +925,22 @@ class Combo:
ray.draw_texture(game_screen.texture_combo_glimmer, x + (i * 30), y + self.glimmer_dict[j], self.color[j]) ray.draw_texture(game_screen.texture_combo_glimmer, x + (i * 30), y + self.glimmer_dict[j], self.color[j])
class ScoreCounter: class ScoreCounter:
def __init__(self, score, current_ms): def __init__(self, score: int, current_ms: float):
self.score = score self.score = score
self.create_ms = current_ms self.create_ms = current_ms
self.stretch_animation = Animation(current_ms, 0, 'text_stretch') self.stretch_animation = Animation(current_ms, 0, 'text_stretch')
def update_count(self, current_ms, score): def update_count(self, current_ms: float, score: int):
if self.score != score: if self.score != score:
self.score = score self.score = score
self.stretch_animation = Animation(current_ms, 50, 'text_stretch') self.stretch_animation = Animation(current_ms, 50, 'text_stretch')
def update(self, current_ms, score): def update(self, current_ms: float, score: int):
self.update_count(current_ms, score) self.update_count(current_ms, score)
self.stretch_animation.update(current_ms) if self.score > 0:
self.stretch_animation.update(current_ms)
def draw(self, game_screen): def draw(self, game_screen: GameScreen):
counter = str(self.score) counter = str(self.score)
x, y = 150, 185 x, y = 150, 185
margin = 20 margin = 20
@@ -984,8 +952,8 @@ class ScoreCounter:
ray.draw_texture_pro(game_screen.texture_score_numbers[int(counter[i])], source_rect, dest_rect, ray.Vector2(0,0), 0, ray.WHITE) ray.draw_texture_pro(game_screen.texture_score_numbers[int(counter[i])], source_rect, dest_rect, ray.Vector2(0,0), 0, ray.WHITE)
class ScoreCounterAnimation: class ScoreCounterAnimation:
def __init__(self, current_ms, counter): def __init__(self, current_ms: float, counter: int):
self.counter = int(counter) self.counter = counter
self.fade_animation_1 = Animation(current_ms, 50, 'fade') self.fade_animation_1 = Animation(current_ms, 50, 'fade')
self.fade_animation_1.params['initial_opacity'] = 0.0 self.fade_animation_1.params['initial_opacity'] = 0.0
self.fade_animation_1.params['final_opacity'] = 1.0 self.fade_animation_1.params['final_opacity'] = 1.0
@@ -1016,7 +984,7 @@ class ScoreCounterAnimation:
self.is_finished = False self.is_finished = False
self.y_pos_list = [] self.y_pos_list = []
def update(self, current_ms): def update(self, current_ms: float):
self.fade_animation_1.update(current_ms) self.fade_animation_1.update(current_ms)
self.move_animation_1.update(current_ms) self.move_animation_1.update(current_ms)
self.move_animation_2.update(current_ms) self.move_animation_2.update(current_ms)
@@ -1034,7 +1002,7 @@ class ScoreCounterAnimation:
for i in range(1, len(str(self.counter))+1): for i in range(1, len(str(self.counter))+1):
self.y_pos_list.append(self.move_animation_4.attribute + i*5) self.y_pos_list.append(self.move_animation_4.attribute + i*5)
def draw(self, game_screen): def draw(self, game_screen: GameScreen):
if self.move_animation_1.is_finished: if self.move_animation_1.is_finished:
x = self.move_animation_2.attribute x = self.move_animation_2.attribute
else: else:
@@ -1045,7 +1013,7 @@ class ScoreCounterAnimation:
margin = 20 margin = 20
total_width = len(counter) * margin total_width = len(counter) * margin
start_x = x - total_width start_x = x - total_width
source_rect = ray.Rectangle(0, 0, game_screen.texture_base_score_numbers[0].width, game_screen.texture_base_score_numbers[0].height) source_rect = ray.Rectangle(0, 0, game_screen.textures['score_add_1p'][0].width, game_screen.textures['score_add_1p'][0].height)
for i in range(len(counter)): for i in range(len(counter)):
if self.move_animation_3.is_finished: if self.move_animation_3.is_finished:
y = self.y_pos_list[i] y = self.y_pos_list[i]
@@ -1053,5 +1021,44 @@ class ScoreCounterAnimation:
y = self.move_animation_3.attribute y = self.move_animation_3.attribute
else: else:
y = 148 y = 148
dest_rect = ray.Rectangle(start_x + (i * margin), y, game_screen.texture_base_score_numbers[0].width, game_screen.texture_base_score_numbers[0].height) dest_rect = ray.Rectangle(start_x + (i * margin), y, game_screen.textures['score_add_1p'][0].width, game_screen.textures['score_add_1p'][0].height)
ray.draw_texture_pro(game_screen.texture_base_score_numbers[int(counter[i])], source_rect, dest_rect, ray.Vector2(0,0), 0, self.color) ray.draw_texture_pro(game_screen.textures['score_add_1p'][int(counter[i])], source_rect, dest_rect, ray.Vector2(0,0), 0, self.color)
class SongInfo:
def __init__(self, current_ms: float, song_name: str, genre: str):
self.fade_in = Animation(current_ms, 366, 'fade')
self.fade_in.params['initial_opacity'] = 0.0
self.fade_in.params['final_opacity'] = 1.0
self.fade_out = Animation(current_ms, 366, 'fade')
self.fade_out.params['initial_opacity'] = 1.0
self.fade_out.params['final_opacity'] = 0.0
self.fade_out.params['delay'] = 1666 + self.fade_in.duration
self.is_finished = False
self.song_num_fade = ray.WHITE
self.song_name_fade = ray.WHITE
codepoint_count = ray.ffi.new('int *', 0)
codepoints_no_dup = set()
codepoints_no_dup.update(song_name)
codepoints = ray.load_codepoints(''.join(codepoints_no_dup), codepoint_count)
self.font = ray.load_font_ex('Graphics\\Modified-DFPKanteiryu-XB.ttf', 32, codepoints, 0)
self.song_title = OutlinedText(self.font, song_name, 40, ray.WHITE, ray.BLACK, outline_thickness=5)
def update(self, current_ms: float):
self.fade_in.update(current_ms)
self.fade_out.update(current_ms)
self.song_num_fade = ray.fade(ray.WHITE, self.fade_in.attribute)
self.song_name_fade = ray.fade(ray.WHITE, 1 - self.fade_in.attribute)
if self.fade_in.is_finished:
self.song_num_fade = ray.fade(ray.WHITE, self.fade_out.attribute)
self.song_name_fade = ray.fade(ray.WHITE, 1 - self.fade_out.attribute)
if self.fade_out.is_finished:
self.fade_in.start_ms = current_ms + 1666
self.fade_out.start_ms = current_ms + 1666
self.fade_in.is_finished = False
self.fade_out.is_finished = False
def draw(self, game_screen: GameScreen):
ray.draw_texture(game_screen.textures['song_info'][(global_data.songs_played % 4) + 8], 1132, 25, self.song_num_fade)
self.song_title.draw(1252 - self.song_title.texture.width, int(50 - self.song_title.texture.height / 2), self.song_name_fade)

13
scenes/result.py
View File

@@ -1,7 +1,7 @@
import pyray as ray import pyray as ray
from libs.audio import audio from libs.audio import audio
from libs.utils import GlobalData from libs.utils import global_data
class ResultScreen: class ResultScreen:
@@ -12,12 +12,13 @@ class ResultScreen:
def update(self): def update(self):
if ray.is_key_pressed(ray.KeyboardKey.KEY_ENTER): if ray.is_key_pressed(ray.KeyboardKey.KEY_ENTER):
global_data.songs_played += 1
audio.play_sound(self.sound_don) audio.play_sound(self.sound_don)
return "SONG_SELECT" return "SONG_SELECT"
def draw(self): def draw(self):
ray.draw_text(f"{GlobalData.selected_song}", 100, 60, 20, ray.BLACK) ray.draw_text(f"{global_data.selected_song}", 100, 60, 20, ray.BLACK)
ray.draw_text(f"SCORE: {GlobalData.result_score}", 100, 80, 20, ray.BLACK) ray.draw_text(f"SCORE: {global_data.result_score}", 100, 80, 20, ray.BLACK)
ray.draw_text(f"GOOD: {GlobalData.result_good}", 100, 100, 20, ray.BLACK) ray.draw_text(f"GOOD: {global_data.result_good}", 100, 100, 20, ray.BLACK)
ray.draw_text(f"OK: {GlobalData.result_ok}", 100, 120, 20, ray.BLACK) ray.draw_text(f"OK: {global_data.result_ok}", 100, 120, 20, ray.BLACK)
ray.draw_text(f"BAD: {GlobalData.result_bad}", 100, 140, 20, ray.BLACK) ray.draw_text(f"BAD: {global_data.result_bad}", 100, 140, 20, ray.BLACK)

33
scenes/song_select.py
View File

@@ -3,18 +3,19 @@ import os
import pyray as ray import pyray as ray
from libs.audio import audio from libs.audio import audio
from libs.utils import GlobalData, get_config from libs.utils import get_config, global_data
class SongSelectScreen: class SongSelectScreen:
def __init__(self, width, height): def __init__(self, width: int, height: int):
self.width = width self.width = width
self.height = height self.height = height
self.is_song_select = True self.is_song_select = True
self.is_difficulty_select = False self.is_difficulty_select = False
self.song_list = [] self.song_list: list[str] = []
self.selected_song = 0 self.selected_song = 0
self.selected_difficulty = 0 self.selected_difficulty = 0
self.selected_index = 0
self.sound_don = audio.load_sound('Sounds\\inst_00_don.wav') self.sound_don = audio.load_sound('Sounds\\inst_00_don.wav')
self.sound_kat = audio.load_sound('Sounds\\inst_00_katsu.wav') self.sound_kat = audio.load_sound('Sounds\\inst_00_katsu.wav')
for dirpath, dirnames, filenames in os.walk(f'{get_config()["paths"]["tja_path"]}'): for dirpath, dirnames, filenames in os.walk(f'{get_config()["paths"]["tja_path"]}'):
@@ -37,9 +38,9 @@ class SongSelectScreen:
def update_difficulty_select(self): def update_difficulty_select(self):
if ray.is_key_pressed(ray.KeyboardKey.KEY_ENTER): if ray.is_key_pressed(ray.KeyboardKey.KEY_ENTER):
audio.play_sound(self.sound_don) audio.play_sound(self.sound_don)
GlobalData.selected_song = self.song_list[self.selected_song] global_data.selected_song = self.song_list[self.selected_song]
GlobalData.selected_difficulty = self.selected_difficulty global_data.selected_difficulty = self.selected_difficulty
GlobalData.start_song = True global_data.start_song = True
self.is_song_select = True self.is_song_select = True
self.is_difficulty_select = False self.is_difficulty_select = False
return "GAME" return "GAME"
@@ -48,10 +49,10 @@ class SongSelectScreen:
self.is_difficulty_select = False self.is_difficulty_select = False
elif ray.is_key_pressed(ray.KeyboardKey.KEY_UP): elif ray.is_key_pressed(ray.KeyboardKey.KEY_UP):
audio.play_sound(self.sound_kat) audio.play_sound(self.sound_kat)
self.selected_difficulty -= 1 self.selected_difficulty = (self.selected_difficulty - 1) % 5
elif ray.is_key_pressed(ray.KeyboardKey.KEY_DOWN): elif ray.is_key_pressed(ray.KeyboardKey.KEY_DOWN):
audio.play_sound(self.sound_kat) audio.play_sound(self.sound_kat)
self.selected_difficulty += 1 self.selected_difficulty = (self.selected_difficulty + 1) % 5
def update(self): def update(self):
if self.is_song_select: if self.is_song_select:
@@ -60,12 +61,22 @@ class SongSelectScreen:
return self.update_difficulty_select() return self.update_difficulty_select()
def draw_song_select(self): def draw_song_select(self):
for i in range(len(self.song_list)): visible_songs = 36
if i == self.selected_song: total_songs = len(self.song_list)
start_index = max(0, self.selected_song - visible_songs // 2)
if start_index + visible_songs > total_songs:
start_index = max(0, total_songs - visible_songs)
for i in range(visible_songs):
song_index = (start_index + i) % total_songs
if song_index == self.selected_song:
color = ray.GREEN color = ray.GREEN
else: else:
color = ray.BLACK color = ray.BLACK
ray.draw_text(self.song_list[i], 20, (20*i), 20, color)
ray.draw_text(self.song_list[song_index], 20, (20*i), 20, color)
def draw_difficulty_select(self): def draw_difficulty_select(self):
difficulties = ["Easy", "Normal", "Hard", "Oni", "Ura"] difficulties = ["Easy", "Normal", "Hard", "Oni", "Ura"]

407
scenes/title.py
View File

@@ -1,5 +1,5 @@
import os
import random import random
from pathlib import Path
import pyray as ray import pyray as ray
@@ -8,6 +8,7 @@ from libs.audio import audio
from libs.utils import ( from libs.utils import (
get_config, get_config,
get_current_ms, get_current_ms,
load_all_textures_from_zip,
load_texture_from_zip, load_texture_from_zip,
) )
from libs.video import VideoPlayer from libs.video import VideoPlayer
@@ -17,45 +18,21 @@ class TitleScreen:
def __init__(self, width: int, height: int): def __init__(self, width: int, height: int):
self.width = width self.width = width
self.height = height self.height = height
self.op_video_list = [] video_dir = Path(get_config()["paths"]["video_path"]) / "op_videos"
self.attract_video_list = [] self.op_video_list = [str(file) for file in video_dir.glob("**/*.mp4")]
for root, folder, files in os.walk(f'{get_config()["paths"]["video_path"]}\\op_videos'): video_dir = Path(get_config()["paths"]["video_path"]) / "attract_videos"
for file in files: self.attract_video_list = [str(file) for file in video_dir.glob("**/*.mp4")]
if file.endswith('.mp4'):
self.op_video_list.append(root + '\\' + file)
for root, folder, files in os.walk(f'{get_config()["paths"]["video_path"]}\\attract_videos'):
for file in files:
if file.endswith('.mp4'):
self.attract_video_list.append(root + '\\' + file)
self.attract_video = VideoPlayer(random.choice(self.attract_video_list)) self.attract_video = VideoPlayer(random.choice(self.attract_video_list))
self.op_video = VideoPlayer(random.choice(self.op_video_list)) self.op_video = VideoPlayer(random.choice(self.op_video_list))
self.scene = 'Opening Video' self.scene = 'Opening Video'
self.load_textures() self.load_textures()
self.warning_board = WarningBoard(get_current_ms(), self) self.warning_board = WarningScreen(get_current_ms(), self)
def get_videos(self):
return self.op_video, self.attract_video
def load_textures(self): def load_textures(self):
zip_file = 'Graphics\\lumendata\\attract\\keikoku.zip' self.textures = load_all_textures_from_zip('Graphics\\lumendata\\attract\\keikoku.zip')
self.texture_bg = load_texture_from_zip(zip_file, 'keikoku_img00000.png')
self.texture_warning = load_texture_from_zip(zip_file, 'keikoku_img00001.png')
self.texture_warning_ch1 = [load_texture_from_zip(zip_file, 'keikoku_img00004.png'),
load_texture_from_zip(zip_file, 'keikoku_img00009.png'),
load_texture_from_zip(zip_file, 'keikoku_img00016.png')]
self.texture_warning_ch1_base = load_texture_from_zip(zip_file, 'keikoku_img00002.png')
self.texture_warning_ch2 = [load_texture_from_zip(zip_file, 'keikoku_img00005.png'),
load_texture_from_zip(zip_file, 'keikoku_img00006.png'),
load_texture_from_zip(zip_file, 'keikoku_img00007.png'),
load_texture_from_zip(zip_file, 'keikoku_img00008.png'),
load_texture_from_zip(zip_file, 'keikoku_img00010.png'),
load_texture_from_zip(zip_file, 'keikoku_img00011.png'),
load_texture_from_zip(zip_file, 'keikoku_img00012.png'),
load_texture_from_zip(zip_file, 'keikoku_img00013.png'),
load_texture_from_zip(zip_file, 'keikoku_img00017.png')]
self.texture_warning_ch2_base = load_texture_from_zip(zip_file, 'keikoku_img00003.png')
self.texture_warning_bachi = load_texture_from_zip(zip_file, 'keikoku_img00019.png')
self.texture_warning_bachi_hit = load_texture_from_zip(zip_file, 'keikoku_img00018.png')
self.texture_warning_x_1 = load_texture_from_zip(zip_file, 'keikoku_img00014.png')
self.texture_warning_x_2 = load_texture_from_zip(zip_file, 'keikoku_img00015.png')
self.sound_bachi_swipe = audio.load_sound('Sounds\\title\\SE_ATTRACT_2.ogg') self.sound_bachi_swipe = audio.load_sound('Sounds\\title\\SE_ATTRACT_2.ogg')
self.sound_bachi_hit = audio.load_sound('Sounds\\title\\SE_ATTRACT_3.ogg') self.sound_bachi_hit = audio.load_sound('Sounds\\title\\SE_ATTRACT_3.ogg')
@@ -69,7 +46,7 @@ class TitleScreen:
self.op_video.update() self.op_video.update()
if all(self.op_video.is_finished): if all(self.op_video.is_finished):
self.scene = 'Warning Board' self.scene = 'Warning Board'
self.warning_board = WarningBoard(get_current_ms(), self) self.warning_board = WarningScreen(get_current_ms(), self)
elif self.scene == 'Warning Board': elif self.scene == 'Warning Board':
self.warning_board.update(get_current_ms(), self) self.warning_board.update(get_current_ms(), self)
if self.warning_board.is_finished: if self.warning_board.is_finished:
@@ -90,188 +67,234 @@ class TitleScreen:
if self.scene == 'Opening Video': if self.scene == 'Opening Video':
self.op_video.draw() self.op_video.draw()
elif self.scene == 'Warning Board': elif self.scene == 'Warning Board':
bg_source = ray.Rectangle(0, 0, self.texture_bg.width, self.texture_bg.height) bg_source = ray.Rectangle(0, 0, self.textures['keikoku'][0].width, self.textures['keikoku'][0].height)
bg_dest = ray.Rectangle(0, 0, self.width, self.height) bg_dest = ray.Rectangle(0, 0, self.width, self.height)
ray.draw_texture_pro(self.texture_bg, bg_source, bg_dest, ray.Vector2(0,0), 0, ray.WHITE) ray.draw_texture_pro(self.textures['keikoku'][0], bg_source, bg_dest, ray.Vector2(0,0), 0, ray.WHITE)
self.warning_board.draw(self) self.warning_board.draw(self)
elif self.scene == 'Attract Video': elif self.scene == 'Attract Video':
self.attract_video.draw() self.attract_video.draw()
ray.draw_text(f"Scene: {self.scene}", 20, 40, 20, ray.BLUE) ray.draw_text(f"Scene: {self.scene}", 20, 40, 20, ray.BLUE)
class WarningBoard: class WarningScreen:
def __init__(self, current_ms, title_screen): class X:
def __init__(self, current_ms: float):
self.delay = 4250
self.resize = Animation(current_ms, 166.67, 'texture_resize')
self.resize.params['initial_size'] = 1.0
self.resize.params['final_size'] = 1.5
self.resize.params['delay'] = self.delay
self.resize.params['reverse'] = 0
self.fadein = Animation(current_ms, 166.67, 'fade')
self.fadein.params['delay'] = self.delay
self.fadein.params['initial_opacity'] = 0.0
self.fadein.params['final_opacity'] = 1.0
self.fadein.params['reverse'] = 166.67
self.fadein_2 = Animation(current_ms, 166.67, 'fade')
self.fadein_2.params['delay'] = self.delay + 166.67 + 166.67
self.fadein_2.params['initial_opacity'] = 0.0
self.fadein_2.params['final_opacity'] = 1.0
self.sound_played = False
def update(self, current_ms: float, sound, elapsed_time):
self.fadein.update(current_ms)
self.fadein_2.update(current_ms)
self.resize.update(current_ms)
if self.delay + self.fadein.duration <= elapsed_time and not self.sound_played:
audio.play_sound(sound)
self.sound_played = True
def draw(self, texture):
scale = self.resize.attribute
width = texture.width
height = texture.height
x_x = 150 + (width//2) - ((width * scale)//2)
x_y = 200 + (height//2) - ((height * scale)//2)
x_source = ray.Rectangle(0, 0, width, height)
x_dest = ray.Rectangle(x_x, x_y, width*scale, height*scale)
ray.draw_texture_pro(texture, x_source, x_dest, ray.Vector2(0,0), 0, ray.fade(ray.WHITE, self.fadein.attribute))
class BachiHit:
def __init__(self, current_ms: float):
self.resize = Animation(current_ms, 233.34, 'texture_resize')
self.resize.params['initial_size'] = 0.5
self.resize.params['final_size'] = 1.5
self.fadein = Animation(current_ms, 116.67, 'fade')
self.fadein.params['initial_opacity'] = 0.0
self.fadein.params['final_opacity'] = 1.0
self.fadein.params['reverse'] = 0
self.sound_played = False
def update(self, current_ms: float, sound):
if not self.sound_played:
audio.play_sound(sound)
self.sound_played = True
self.resize.start_ms = current_ms
self.fadein.start_ms = current_ms
self.resize.update(current_ms)
self.fadein.update(current_ms)
def draw(self, texture):
scale = self.resize.attribute
width = texture.width
height = texture.height
hit_x = 350 + (width//2) - ((width * scale)//2)
hit_y = 225 + (height//2) - ((height * scale)//2)
hit_source = ray.Rectangle(0, 0, width, height)
hit_dest = ray.Rectangle(hit_x, hit_y, width*scale, height*scale)
ray.draw_texture_pro(texture, hit_source, hit_dest, ray.Vector2(0,0), 0, ray.fade(ray.WHITE, self.fadein.attribute))
class Characters:
def __init__(self, current_ms: float, start_ms: float):
self.start_ms = start_ms
self.current_ms = current_ms
self.shadow_fade = Animation(current_ms, 50, 'fade')
self.shadow_fade.params['delay'] = 16.67
self.shadow_fade.params['initial_opacity'] = 0.75
self.animation_sequence = [(300.00, 5, 4), (183.33, 6, 4), (166.67, 7, 4), (166.67, 8, 9), (166.67, 11, 9), (166.67, 12, 9), (166.67, 13, 9),
(166.67, 5, 4), (150.00, 5, 4), (133.34, 6, 4), (133.34, 7, 4), (133.34, 8, 9), (133.34, 11, 9), (133.34, 12, 9), (133.34, 13, 9),
(133.34, 5, 4), (116.67, 5, 4), (100.00, 6, 4), (100.00, 7, 4), (100.00, 8, 9), (100.00, 11, 9), (100.00, 12, 9), (100.00, 13, 9),
(100.00, 5, 4), (100.00, 5, 4), (83.330, 6, 4), (83.330, 7, 4), (83.330, 8, 9), (83.330, 11, 9), (83.330, 12, 9), (83.330, 13, 9),
(83.330, 5, 4), (83.330, 5, 4), (66.670, 6, 4), (66.670, 7, 4), (66.670, 8, 9), (66.670, 11, 9), (66.670, 12, 9), (66.670, 13, 9),
(66.670, 5, 4), (66.670, 5, 4), (66.670, 6, 4), (66.670, 7, 4), (66.670, 8, 9), (66.670, 11, 9), (66.670, 12, 9), (66.670, 13, 9),
(66.670, 5, 4), (66.670, 5, 4), (66.670, 6, 4), (66.670, 7, 4), (66.670, 8, 9), (66.670, 11, 9), (66.670, 12, 9), (66.670, 13, 9),
(66.670, 17, 16)]
self.time = 0
self.index_val = 0
self.is_finished = False
def character_index(self, index: int) -> int:
elapsed_time = self.current_ms - self.start_ms
delay = 566.67
if self.index_val == len(self.animation_sequence)-1:
return int(self.animation_sequence[len(self.animation_sequence)-1][index])
elif elapsed_time <= delay:
return int(self.animation_sequence[0][index])
elif elapsed_time >= delay + self.time:
new_index = self.animation_sequence[self.index_val][index]
self.index_val += 1
self.shadow_fade.start_ms = self.current_ms
self.shadow_fade.duration = int(self.animation_sequence[self.index_val][0])
self.time += self.animation_sequence[self.index_val][0]
return int(new_index)
else:
return int(self.animation_sequence[self.index_val][index])
def update(self, current_ms: float):
self.shadow_fade.update(current_ms)
self.current_ms = current_ms
self.is_finished = True if self.character_index(1) == self.animation_sequence[-1][1] else False
def draw(self, textures, fade: ray.Color, fade_2: ray.Color, y: int):
ray.draw_texture(textures['keikoku'][2], 135, y+textures['keikoku'][4].height+110, fade_2)
ray.draw_texture(textures['keikoku'][self.character_index(2)], 115, y+150, fade)
ray.draw_texture(textures['keikoku'][3], 360, y+textures['keikoku'][5].height+60, fade_2)
if 6 < self.character_index(1) < 17:
ray.draw_texture(textures['keikoku'][self.character_index(1) - 1], 315, y+100, ray.fade(ray.WHITE, self.shadow_fade.attribute))
ray.draw_texture(textures['keikoku'][self.character_index(1)], 315, y+100, fade)
if self.character_index(1) == 17:
ray.draw_texture(textures['keikoku'][19], 350, y+135, ray.WHITE)
class Board:
def __init__(self, current_ms: float, screen_width, screen_height, texture):
#Move warning board down from top of screen
self.move_down = Animation(current_ms, 266.67, 'move')
self.move_down.params['start_position'] = -720
self.move_down.params['total_distance'] = screen_height + ((screen_height - texture.height)//2) + 20
#Move warning board up a little bit
self.move_up = Animation(current_ms, 116.67, 'move')
self.move_up.params['start_position'] = 92 + 20
self.move_up.params['delay'] = self.move_down.duration
self.move_up.params['total_distance'] = -30
#And finally into its correct position
self.move_center = Animation(current_ms, 116.67, 'move')
self.move_center.params['start_position'] = 82
self.move_center.params['delay'] = self.move_down.duration + self.move_up.duration
self.move_center.params['total_distance'] = 10
self.y_pos = 0
def update(self, current_ms):
self.move_down.update(current_ms)
self.move_up.update(current_ms)
self.move_center.update(current_ms)
if self.move_up.is_finished:
self.y_pos = int(self.move_center.attribute)
elif self.move_down.is_finished:
self.y_pos = int(self.move_up.attribute)
else:
self.y_pos = int(self.move_down.attribute)
def draw(self, texture):
ray.draw_texture(texture, 0, self.y_pos, ray.WHITE)
def __init__(self, current_ms: float, title_screen: TitleScreen):
self.start_ms = current_ms self.start_ms = current_ms
self.error_time = 4250
#Move warning board down from top of screen self.fade_in = Animation(current_ms, 300, 'fade')
self.move_animation_1 = Animation(current_ms, 266.67, 'move') self.fade_in.params['delay'] = 266.67
self.move_animation_1.params['start_position'] = -720 self.fade_in.params['initial_opacity'] = 0.0
self.move_animation_1.params['total_distance'] = title_screen.height + ((title_screen.height - title_screen.texture_warning.height)//2) + 20 self.fade_in.params['final_opacity'] = 1.0
#Move warning board up a little bit
self.move_animation_2 = Animation(current_ms, 116.67, 'move')
self.move_animation_2.params['start_position'] = 92 + 20
self.move_animation_2.params['delay'] = 266.67
self.move_animation_2.params['total_distance'] = -30
#And finally into its correct position
self.move_animation_3 = Animation(current_ms, 116.67, 'move')
self.move_animation_3.params['start_position'] = 82
self.move_animation_3.params['delay'] = 383.34
self.move_animation_3.params['total_distance'] = 10
self.fade_animation_1 = Animation(current_ms, 300, 'fade')
self.fade_animation_1.params['delay'] = 266.67
self.fade_animation_1.params['initial_opacity'] = 0.0
self.fade_animation_1.params['final_opacity'] = 1.0
#Fade to black #Fade to black
self.fade_animation_2 = Animation(current_ms, 500, 'fade') self.fade_out = Animation(current_ms, 500, 'fade')
self.fade_animation_2.params['initial_opacity'] = 0.0 self.fade_out.params['initial_opacity'] = 0.0
self.fade_animation_2.params['final_opacity'] = 1.0 self.fade_out.params['final_opacity'] = 1.0
self.fade_animation_2.params['delay'] = 500 self.fade_out.params['delay'] = 1000
self.fade_animation_3 = Animation(current_ms, 50, 'fade') self.board = self.Board(current_ms, title_screen.width, title_screen.height, title_screen.textures['keikoku'][1])
self.fade_animation_3.params['delay'] = 16.67 self.warning_x = self.X(current_ms)
self.fade_animation_3.params['initial_opacity'] = 0.75 self.warning_bachi_hit = self.BachiHit(current_ms)
self.characters = self.Characters(current_ms, self.start_ms)
self.resize_animation_1 = Animation(current_ms, 166.67, 'texture_resize')
self.resize_animation_1.params['initial_size'] = 1.0
self.resize_animation_1.params['final_size'] = 1.5
self.resize_animation_1.params['delay'] = self.error_time
self.resize_animation_1.params['reverse'] = 0
self.fade_animation_4 = Animation(current_ms, 166.67, 'fade')
self.fade_animation_4.params['delay'] = self.error_time
self.fade_animation_4.params['initial_opacity'] = 0.0
self.fade_animation_4.params['final_opacity'] = 1.0
self.fade_animation_4.params['reverse'] = 166.67
self.fade_animation_6 = Animation(current_ms, 166.67, 'fade')
self.fade_animation_6.params['delay'] = self.error_time + 166.67 + 166.67
self.fade_animation_6.params['initial_opacity'] = 0.0
self.fade_animation_6.params['final_opacity'] = 1.0
#Bachi hit
self.resize_animation_3 = Animation(current_ms, 233.34, 'texture_resize')
self.resize_animation_3.params['initial_size'] = 0.5
self.resize_animation_3.params['final_size'] = 1.5
#Bachi hit
self.fade_animation_7 = Animation(current_ms, 116.67, 'fade')
self.fade_animation_7.params['initial_opacity'] = 0.0
self.fade_animation_7.params['final_opacity'] = 1.0
self.fade_animation_7.params['reverse'] = 0
self.source_rect = ray.Rectangle(0, 0, title_screen.texture_black.width, title_screen.texture_black.height) self.source_rect = ray.Rectangle(0, 0, title_screen.texture_black.width, title_screen.texture_black.height)
self.dest_rect = ray.Rectangle(0, 0, title_screen.width, title_screen.height) self.dest_rect = ray.Rectangle(0, 0, title_screen.width, title_screen.height)
self.character_time = 0
self.character_index_val = 0
self.hit_played = False
self.error_played = False
self.is_finished = False self.is_finished = False
self.attract_frame_index = 0 def update(self, current_ms: float, title_screen: TitleScreen):
self.board.update(current_ms)
def load_next_attract(self, title_screen): self.fade_in.update(current_ms)
if title_screen.current_attract_video.convert_frames_background(self.attract_frame_index) == 0: self.fade_out.update(current_ms)
return 0
self.attract_frame_index += 1
def update(self, current_ms, title_screen):
self.move_animation_1.update(current_ms)
self.move_animation_2.update(current_ms)
self.move_animation_3.update(current_ms)
self.fade_animation_1.update(current_ms)
self.fade_animation_2.update(current_ms)
self.fade_animation_3.update(current_ms)
self.fade_animation_4.update(current_ms)
self.fade_animation_6.update(current_ms)
self.resize_animation_1.update(current_ms)
delay = 566.67 delay = 566.67
elapsed_time = current_ms - self.start_ms elapsed_time = current_ms - self.start_ms
if self.character_index(1) != 8: self.warning_x.update(current_ms, title_screen.sound_warning_error, elapsed_time)
self.fade_animation_2.params['delay'] = elapsed_time + 500 self.characters.update(current_ms)
if self.characters.is_finished:
self.warning_bachi_hit.update(current_ms, title_screen.sound_bachi_hit)
else:
self.fade_out.params['delay'] = elapsed_time + 500
if delay <= elapsed_time and not audio.is_sound_playing(title_screen.sound_bachi_swipe): if delay <= elapsed_time and not audio.is_sound_playing(title_screen.sound_bachi_swipe):
audio.play_sound(title_screen.sound_warning_message) audio.play_sound(title_screen.sound_warning_message)
audio.play_sound(title_screen.sound_bachi_swipe) audio.play_sound(title_screen.sound_bachi_swipe)
elif self.character_index(1) == 8:
if not self.hit_played:
self.hit_played = True
audio.play_sound(title_screen.sound_bachi_hit)
self.resize_animation_3.start_ms = current_ms
self.fade_animation_7.start_ms = current_ms
self.resize_animation_3.update(current_ms)
self.fade_animation_7.update(current_ms)
if self.error_time + 166.67 <= elapsed_time and not self.error_played: self.is_finished = self.fade_out.is_finished
self.error_played = True
audio.play_sound(title_screen.sound_warning_error)
if self.fade_animation_2.is_finished:
self.is_finished = True
def character_index(self, index): def draw(self, title_screen: TitleScreen):
elapsed_time = get_current_ms() - self.start_ms fade = ray.fade(ray.WHITE, self.fade_in.attribute)
delay = 566.67 fade_2 = ray.fade(ray.WHITE, self.fade_in.attribute if self.fade_in.attribute < 0.75 else 0.75)
animation = [(300.00, 1, 0), (183.33, 2, 0), (166.67, 3, 0), (166.67, 4, 1), (166.67, 5, 1), (166.67, 6, 1), (166.67, 7, 1), self.board.draw(title_screen.textures['keikoku'][1])
(166.67, 0, 0), (150.00, 1, 0), (133.34, 2, 0), (133.34, 3, 0), (133.34, 4, 1), (133.34, 5, 1), (133.34, 6, 1), (133.34, 7, 1), ray.draw_texture(title_screen.textures['keikoku'][15], 150, 200, ray.fade(ray.WHITE, self.warning_x.fadein_2.attribute))
(133.34, 0, 0), (116.67, 1, 0), (100.00, 2, 0), (100.00, 3, 0), (100.00, 4, 1), (100.00, 5, 1), (100.00, 6, 1), (100.00, 7, 1),
(100.00, 0, 0), (100.00, 1, 0), (83.330, 2, 0), (83.330, 3, 0), (83.330, 4, 1), (83.330, 5, 1), (83.330, 6, 1), (83.330, 7, 1),
(83.330, 0, 0), (83.330, 1, 0), (66.670, 2, 0), (66.670, 3, 0), (66.670, 4, 1), (66.670, 5, 1), (66.670, 6, 1), (66.670, 7, 1),
(66.670, 0, 0), (66.670, 1, 0), (66.670, 2, 0), (66.670, 3, 0), (66.670, 4, 1), (66.670, 5, 1), (66.670, 6, 1), (66.670, 7, 1),
(66.670, 0, 0), (66.670, 1, 0), (66.670, 2, 0), (66.670, 3, 0), (66.670, 4, 1), (66.670, 5, 1), (66.670, 6, 1), (66.670, 7, 1),
(66.670, 8, 2)]
if self.character_index_val == len(animation)-1:
return animation[len(animation)-1][index]
elif elapsed_time <= delay:
return 0
elif elapsed_time >= delay + self.character_time:
new_index = animation[self.character_index_val][index]
self.character_index_val += 1
self.fade_animation_3.start_ms = get_current_ms()
self.fade_animation_3.duration = int(animation[self.character_index_val][0])
self.character_time += animation[self.character_index_val][0]
return new_index
else:
return animation[self.character_index_val][index]
def draw(self, title_screen): self.characters.draw(title_screen.textures, fade, fade_2, self.board.y_pos)
if self.move_animation_2.is_finished:
y = self.move_animation_3.attribute
elif self.move_animation_1.is_finished:
y = self.move_animation_2.attribute
else:
y = self.move_animation_1.attribute
ray.draw_texture(title_screen.texture_warning, 0, int(y), ray.WHITE)
fade = ray.fade(ray.WHITE, self.fade_animation_1.attribute)
fade_2 = ray.fade(ray.WHITE, self.fade_animation_1.attribute if self.fade_animation_1.attribute < 0.75 else 0.75)
ray.draw_texture(title_screen.texture_warning_x_2, 150, 200, ray.fade(ray.WHITE, self.fade_animation_6.attribute))
ray.draw_texture(title_screen.texture_warning_ch1_base, 135, int(y)+title_screen.texture_warning_ch1[0].height+110, fade_2)
ray.draw_texture(title_screen.texture_warning_ch1[self.character_index(2)], 115, int(y)+150, fade)
ray.draw_texture(title_screen.texture_warning_ch2_base, 360, int(y)+title_screen.texture_warning_ch2[0].height+60, fade_2)
if 0 < self.character_index(1):
ray.draw_texture(title_screen.texture_warning_ch2[self.character_index(1)-1], 315, int(y)+100, ray.fade(ray.WHITE, self.fade_animation_3.attribute))
ray.draw_texture(title_screen.texture_warning_ch2[self.character_index(1)], 315, int(y)+100, fade)
if self.character_index(1) == 8:
ray.draw_texture(title_screen.texture_warning_bachi, 350, int(y)+135, ray.WHITE)
scale = self.resize_animation_1.attribute self.warning_x.draw(title_screen.textures['keikoku'][14])
width = title_screen.texture_warning_x_1.width
height = title_screen.texture_warning_x_1.height
x_x = 150 + (width//2) - ((width * scale)//2)
x_y = 200 + (height//2) - ((height * scale)//2)
x_source = ray.Rectangle(0, 0, width, height)
x_dest = ray.Rectangle(x_x, x_y, width*scale, height*scale)
ray.draw_texture_pro(title_screen.texture_warning_x_1, x_source, x_dest, ray.Vector2(0,0), 0, ray.fade(ray.WHITE, self.fade_animation_4.attribute))
scale = self.resize_animation_3.attribute self.warning_bachi_hit.draw(title_screen.textures['keikoku'][18])
width = title_screen.texture_warning_bachi_hit.width
height = title_screen.texture_warning_bachi_hit.height ray.draw_texture_pro(title_screen.texture_black, self.source_rect, self.dest_rect, ray.Vector2(0,0), 0, ray.fade(ray.WHITE, self.fade_out.attribute))
hit_x = 350 + (width//2) - ((width * scale)//2)
hit_y = 225 + (height//2) - ((height * scale)//2)
hit_source = ray.Rectangle(0, 0, width, height)
hit_dest = ray.Rectangle(hit_x, hit_y, width*scale, height*scale)
ray.draw_texture_pro(title_screen.texture_warning_bachi_hit, hit_source, hit_dest, ray.Vector2(0,0), 0, ray.fade(ray.WHITE, self.fade_animation_7.attribute))
ray.draw_texture_pro(title_screen.texture_black, self.source_rect, self.dest_rect, ray.Vector2(0,0), 0, ray.fade(ray.WHITE, self.fade_animation_2.attribute))