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

add new texture wrapper

Browse Source
This commit is contained in:
Yonokid
2025-08-05 16:48:50 -04:00
parent 57383339cc
commit bb3a2a1a38
15 changed files with 1522 additions and 1209 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
scenes/devtest.py
View File

@@ -24,4 +24,4 @@ class DevScreen:
pass
def draw_3d(self):
pass
pass

442
scenes/entry.py
View File

@@ -2,18 +2,15 @@ from pathlib import Path
import pyray as ray
from libs.animation import Animation
from libs.audio import audio
from libs.texture import tex
from libs.utils import (
OutlinedText,
draw_scaled_texture,
get_current_ms,
is_l_don_pressed,
is_l_kat_pressed,
is_r_don_pressed,
is_r_kat_pressed,
load_all_textures_from_zip,
load_texture_from_zip,
)
@@ -26,19 +23,9 @@ class EntryScreen:
self.width = width
self.height = height
self.screen_init = False
self.box_titles: list[tuple[OutlinedText, OutlinedText]] = [(OutlinedText('演奏ゲーム', 50, ray.WHITE, ray.Color(109, 68, 24, 255), outline_thickness=5, vertical=True),
OutlinedText('演奏ゲーム', 50, ray.WHITE, ray.BLACK, outline_thickness=5, vertical=True)),
(OutlinedText('ゲーム設定', 50, ray.WHITE, ray.Color(109, 68, 24, 255), outline_thickness=5, vertical=True),
OutlinedText('ゲーム設定', 50, ray.WHITE, ray.BLACK, outline_thickness=5, vertical=True))]
def load_textures(self):
self.textures = load_all_textures_from_zip(Path('Graphics/lumendata/entry.zip'))
self.texture_black = load_texture_from_zip(Path('Graphics/lumendata/attract/movie.zip'), 'movie_img00000.png')
def unload_textures(self):
for group in self.textures:
for texture in self.textures[group]:
ray.unload_texture(texture)
tex.load_screen_textures('entry')
def load_sounds(self):
sounds_dir = Path("Sounds")
@@ -51,43 +38,44 @@ class EntryScreen:
self.load_textures()
self.load_sounds()
self.side = 1
self.selected_box = 0
self.num_boxes = 2
self.box_manager = BoxManager()
self.state = State.SELECT_SIDE
self.screen_init = True
self.drum_move_1 = None
self.drum_move_2 = None
self.drum_move_3 = None
self.cloud_resize = None
self.cloud_texture_change = None
self.cloud_fade = None
self.fade_out = None
self.cloud_resize_loop = Animation.create_texture_resize(200, initial_size=1.0, final_size=1.1, reverse_delay=200)
self.side_select_fade = Animation.create_fade(100, initial_opacity=0.0, final_opacity=1.0)
self.bg_flicker = Animation.create_fade(500, initial_opacity=0.5, final_opacity=0.4, reverse_delay=0)
self.side_select_fade = tex.get_animation(0)
self.bg_flicker = tex.get_animation(1)
self.drum_move_1 = tex.get_animation(2)
self.drum_move_2 = tex.get_animation(3)
self.drum_move_3 = tex.get_animation(4)
self.cloud_resize = tex.get_animation(5)
self.cloud_resize_loop = tex.get_animation(6)
self.cloud_texture_change = tex.get_animation(7)
self.cloud_fade = tex.get_animation(8)
self.cloud_resize_loop.start()
self.side_select_fade.start()
self.bg_flicker.start()
audio.play_sound(self.bgm)
def on_screen_end(self, next_screen: str):
self.screen_init = False
self.unload_textures()
audio.stop_sound(self.bgm)
tex.unload_textures()
audio.unload_all_sounds()
return next_screen
def handle_input(self):
if self.fade_out is not None:
if self.box_manager.is_box_selected():
return
if self.state == State.SELECT_SIDE:
if is_l_don_pressed() or is_r_don_pressed():
if self.side == 1:
return self.on_screen_end("TITLE")
self.drum_move_1 = Animation.create_move(350, total_distance=-295, ease_out='quadratic')
self.drum_move_2 = Animation.create_move(200, total_distance=50, delay=self.drum_move_1.duration, ease_in='quadratic')
self.drum_move_3 = Animation.create_move(350, total_distance=-170, delay=self.drum_move_1.duration+self.drum_move_2.duration, ease_out='quadratic')
self.cloud_resize = Animation.create_texture_resize(350, initial_size=0.75, final_size=1.0)
self.cloud_resize_loop = Animation.create_texture_resize(200, initial_size=1.0, final_size=1.2, reverse_delay=200, delay=self.cloud_resize.duration)
textures = ((0, 83.35, 45), (83.35, 166.7, 48), (166.7, 250, 49), (250, 333, 50))
self.cloud_texture_change = Animation.create_texture_change(333, textures=textures, delay=self.drum_move_1.duration+self.drum_move_2.duration+self.drum_move_3.duration)
self.cloud_fade = Animation.create_fade(83.35, delay=self.drum_move_1.duration+self.drum_move_2.duration+self.drum_move_3.duration+self.cloud_texture_change.duration)
self.drum_move_1.start()
self.drum_move_2.start()
self.drum_move_3.start()
self.cloud_resize.start()
self.cloud_resize_loop.start()
self.cloud_texture_change.start()
self.cloud_fade.start()
self.state = State.SELECT_MODE
audio.play_sound(self.sound_don)
if is_l_kat_pressed():
@@ -99,13 +87,13 @@ class EntryScreen:
elif self.state == State.SELECT_MODE:
if is_l_don_pressed() or is_r_don_pressed():
audio.play_sound(self.sound_don)
self.fade_out = Animation.create_fade(160)
self.box_manager.select_box()
if is_l_kat_pressed():
audio.play_sound(self.sound_kat)
self.selected_box = max(0, self.selected_box - 1)
self.box_manager.move_left()
if is_r_kat_pressed():
audio.play_sound(self.sound_kat)
self.selected_box = min(self.num_boxes - 1, self.selected_box + 1)
self.box_manager.move_right()
def update(self):
self.on_screen_start()
@@ -113,197 +101,255 @@ class EntryScreen:
self.bg_flicker.update(get_current_ms())
if self.bg_flicker.is_finished:
self.bg_flicker.restart()
if self.drum_move_1 is not None:
self.drum_move_1.update(get_current_ms())
if self.drum_move_2 is not None:
self.drum_move_2.update(get_current_ms())
if self.drum_move_3 is not None:
self.drum_move_3.update(get_current_ms())
if self.cloud_resize is not None:
self.cloud_resize.update(get_current_ms())
if self.cloud_texture_change is not None:
self.cloud_texture_change.update(get_current_ms())
if self.cloud_fade is not None:
self.cloud_fade.update(get_current_ms())
self.drum_move_1.update(get_current_ms())
self.drum_move_2.update(get_current_ms())
self.drum_move_3.update(get_current_ms())
self.cloud_resize.update(get_current_ms())
self.cloud_texture_change.update(get_current_ms())
self.cloud_fade.update(get_current_ms())
self.cloud_resize_loop.update(get_current_ms())
if self.cloud_resize_loop.is_finished:
self.cloud_resize_loop = Animation.create_texture_resize(200, initial_size=1.0, final_size=1.1, reverse_delay=200)
if self.fade_out is not None:
self.fade_out.update(get_current_ms())
if self.fade_out.is_finished:
if self.selected_box == 0:
return self.on_screen_end("SONG_SELECT")
elif self.selected_box == 1:
return self.on_screen_end("SETTINGS")
self.cloud_resize_loop.restart()
self.box_manager.update(get_current_ms())
if self.box_manager.is_finished():
return self.on_screen_end(self.box_manager.selected_box())
return self.handle_input()
def draw_background(self):
bg_texture = self.textures['entry'][368]
src = ray.Rectangle(0, 0, bg_texture.width, bg_texture.height)
dest = ray.Rectangle(0, 0, self.width, bg_texture.height)
ray.draw_texture_pro(bg_texture, src, dest, ray.Vector2(0, 0), 0, ray.WHITE)
ray.draw_texture(self.textures['entry'][369], (self.width // 2) - (self.textures['entry'][369].width // 2), (self.height // 2) - self.textures['entry'][369].height, ray.WHITE)
ray.draw_texture(self.textures['entry'][370], 0, (self.height // 2) - (self.textures['entry'][370].height // 2), ray.WHITE)
ray.draw_texture(self.textures['entry'][371], (self.width // 2) - (self.textures['entry'][371].width // 2), (self.height // 2) - (self.textures['entry'][371].height // 2) + 10, ray.WHITE)
ray.draw_texture(self.textures['entry'][372], 0, 0, ray.WHITE)
ray.draw_texture(self.textures['entry'][373], self.width - self.textures['entry'][373].width, 0, ray.WHITE)
draw_scaled_texture(self.textures['entry'][374], -7, -15, 2.0, ray.fade(ray.WHITE, self.bg_flicker.attribute))
tex.draw_texture('background', 'bg')
tex.draw_texture('background', 'tower')
tex.draw_texture('background', 'shops_center')
tex.draw_texture('background', 'people')
tex.draw_texture('background', 'shops_left')
tex.draw_texture('background', 'shops_right')
tex.draw_texture('background', 'lights', scale=2.0, color=ray.fade(ray.WHITE, self.bg_flicker.attribute))
def draw_footer(self):
ray.draw_texture(self.textures['entry'][375], 1, self.height - self.textures['entry'][375].height + 7, ray.WHITE)
tex.draw_texture('side_select', 'footer')
if self.state == State.SELECT_SIDE or self.side != 0:
ray.draw_texture(self.textures['entry'][376], 1, self.height - self.textures['entry'][376].height + 1, ray.WHITE)
tex.draw_texture('side_select', 'footer_left')
if self.state == State.SELECT_SIDE or self.side != 2:
ray.draw_texture(self.textures['entry'][377], 2 + self.textures['entry'][377].width, self.height - self.textures['entry'][376].height + 1, ray.WHITE)
tex.draw_texture('side_select', 'footer_right')
def draw_side_select(self, fade):
color = ray.fade(ray.WHITE, fade)
left_x, top_y, right_x, bottom_y = 238, 108, 979, 520
ray.draw_texture(self.textures['entry'][205], left_x, top_y, color)
ray.draw_texture(self.textures['entry'][208], right_x, top_y, color)
ray.draw_texture(self.textures['entry'][204], left_x, bottom_y, color)
ray.draw_texture(self.textures['entry'][207], right_x, bottom_y, color)
tex.draw_texture('side_select', 'box_top_left', color=color)
tex.draw_texture('side_select', 'box_top_right', color=color)
tex.draw_texture('side_select', 'box_bottom_left', color=color)
tex.draw_texture('side_select', 'box_bottom_right', color=color)
texture = self.textures['entry'][209]
src = ray.Rectangle(0, 0, texture.width, texture.height)
dest = ray.Rectangle(left_x + self.textures['entry'][205].width, top_y, right_x - left_x - (self.textures['entry'][205].width), texture.height)
ray.draw_texture_pro(texture, src, dest, ray.Vector2(0, 0), 0, color)
texture = self.textures['entry'][210]
src = ray.Rectangle(0, 0, texture.width, texture.height)
dest = ray.Rectangle(left_x + self.textures['entry'][205].width, bottom_y, right_x - left_x - (self.textures['entry'][205].width), texture.height)
ray.draw_texture_pro(texture, src, dest, ray.Vector2(0, 0), 0, color)
tex.draw_texture('side_select', 'box_top', color=color)
tex.draw_texture('side_select', 'box_bottom', color=color)
tex.draw_texture('side_select', 'box_left', color=color)
tex.draw_texture('side_select', 'box_right', color=color)
tex.draw_texture('side_select', 'box_center', color=color)
texture = self.textures['entry'][203]
src = ray.Rectangle(0, 0, texture.width, texture.height)
dest = ray.Rectangle(left_x, top_y + self.textures['entry'][205].height, texture.width, bottom_y - top_y - (self.textures['entry'][205].height))
ray.draw_texture_pro(texture, src, dest, ray.Vector2(0, 0), 0, color)
texture = self.textures['entry'][206]
src = ray.Rectangle(0, 0, texture.width, texture.height)
dest = ray.Rectangle(right_x, top_y + self.textures['entry'][205].height, texture.width, bottom_y - top_y - (self.textures['entry'][205].height))
ray.draw_texture_pro(texture, src, dest, ray.Vector2(0, 0), 0, color)
tex.draw_texture('side_select', 'question', color=color)
texture = self.textures['entry'][202]
src = ray.Rectangle(0, 0, texture.width, texture.height)
dest = ray.Rectangle(left_x + self.textures['entry'][205].width, top_y + self.textures['entry'][205].height, right_x - left_x - (self.textures['entry'][205].width), bottom_y - top_y - (self.textures['entry'][205].height))
ray.draw_texture_pro(texture, src, dest, ray.Vector2(0, 0), 0, color)
ray.draw_texture(self.textures['entry'][226], 384, 144, color)
cursor_x = 261
cursor_texture = self.textures['entry'][230]
flip = 1
tex.draw_texture('side_select', '1P', color=color)
tex.draw_texture('side_select', 'cancel', color=color)
tex.draw_texture('side_select', '2P', color=color)
if self.side == 0:
texture = self.textures['entry'][229]
flip = -1
tex.draw_texture('side_select', '1P_highlight', color=color)
tex.textures['side_select']['1P2P_outline'].x = 261
tex.draw_texture('side_select', '1P2P_outline', color=color, mirror='horizontal')
elif self.side == 1:
tex.draw_texture('side_select', 'cancel_highlight', color=color)
tex.draw_texture('side_select', 'cancel_outline', color=color)
else:
texture = self.textures['entry'][232]
ray.draw_texture(texture, 261, 400, color)
if self.side == 1:
texture = self.textures['entry'][76]
cursor_texture = self.textures['entry'][77]
cursor_x = 512
else:
texture = self.textures['entry'][228]
ray.draw_texture(texture, 512, 400, color)
ray.draw_texture(self.textures['entry'][201], 512, 408, color)
if self.side == 2:
texture = self.textures['entry'][233]
cursor_x = 762
else:
texture = self.textures['entry'][227]
ray.draw_texture(texture, 762, 400, color)
src = ray.Rectangle(0, 0, cursor_texture.width * flip, cursor_texture.height)
dest = ray.Rectangle(cursor_x, 400, cursor_texture.width, cursor_texture.height)
ray.draw_texture_pro(cursor_texture, src, dest, ray.Vector2(0, 0), 0, color)
tex.draw_texture('side_select', '2P_highlight', color=color)
tex.textures['side_select']['1P2P_outline'].x = 762
tex.draw_texture('side_select', '1P2P_outline', color=color)
tex.draw_texture('side_select', 'cancel_text', color=color)
def draw_player_drum(self):
move_x = 0
if self.drum_move_3 is not None:
move_x = int(self.drum_move_3.attribute)
move_x = self.drum_move_3.attribute
move_y = self.drum_move_1.attribute + self.drum_move_2.attribute
tex.update_attr('side_select', 'red_drum', 'x', move_x)
tex.update_attr('side_select', 'red_drum', 'y', move_y)
tex.update_attr('side_select', 'blue_drum', 'y', move_y)
if self.side == 0:
drum_texture = self.textures['entry'][366]
x = 160
else:
drum_texture = self.textures['entry'][367]
x = 780
move_x = move_x * -1
move_y = 0
if self.drum_move_1 is not None:
move_y = int(self.drum_move_1.attribute)
if self.drum_move_2 is not None:
move_y += int(self.drum_move_2.attribute)
ray.draw_texture(drum_texture, x + move_x, 720 + move_y, ray.WHITE)
if self.cloud_resize is not None and not self.cloud_resize.is_finished:
scale = self.cloud_resize.attribute
tex.draw_texture('side_select', 'red_drum')
else:
move_x *= -1
tex.textures['side_select']['cloud'].init_vals['x'] = tex.textures['side_select']['blue_drum'].init_vals['x']
tex.update_attr('side_select', 'blue_drum', 'x', move_x)
tex.draw_texture('side_select', 'blue_drum')
scale = self.cloud_resize.attribute
if self.cloud_resize.is_finished:
scale = max(1, self.cloud_resize_loop.attribute)
texture_index = 45
if self.cloud_texture_change is not None and self.cloud_texture_change.attribute != 0:
texture_index = self.cloud_texture_change.attribute
color = ray.fade(ray.WHITE, 1.0)
if self.cloud_fade is not None:
color = ray.fade(ray.WHITE, self.cloud_fade.attribute)
draw_scaled_texture(self.textures['entry'][texture_index], x + move_x - int(160 * (scale-1)), 720 + move_y - 200 - int(160 * (scale-1)), scale, color)
color = ray.fade(ray.WHITE, self.cloud_fade.attribute)
tex.update_attr('side_select', 'cloud', 'x', move_x)
tex.update_attr('side_select', 'cloud', 'y', move_y)
tex.draw_texture('side_select', 'cloud', frame=self.cloud_texture_change.attribute, color=color, scale=scale, center=True)
def draw_mode_select(self, fade):
def draw_mode_select(self):
self.draw_player_drum()
color = ray.fade(ray.WHITE, fade)
if self.cloud_fade is not None and self.cloud_fade.is_finished:
box_width = self.textures['entry'][262].width
spacing = 80
push_distance = 50
total_width = self.num_boxes * box_width + (self.num_boxes - 1) * spacing
start_x = self.width//2 - total_width//2
y = self.height//2 - (self.textures['entry'][262].height//2) - 15
for i in range(self.num_boxes):
x_pos = start_x + i * (box_width + spacing)
push_offset = 0
if i != self.selected_box:
if i < self.selected_box:
push_offset = -push_distance
else:
push_offset = push_distance
final_x = x_pos + push_offset
ray.draw_texture(self.textures['entry'][262], final_x, y, color)
if i == self.selected_box:
ray.draw_texture(self.textures['entry'][302], final_x, y, color)
texture = self.textures['entry'][304]
src = ray.Rectangle(0, 0, texture.width, texture.height)
dest = ray.Rectangle(final_x + self.textures['entry'][302].width, y, 100 - self.textures['entry'][302].width, texture.height)
ray.draw_texture_pro(texture, src, dest, ray.Vector2(0, 0), 0, color)
ray.draw_texture(self.textures['entry'][303], final_x+100, y, color)
box_title = self.box_titles[i][1]
src = ray.Rectangle(0, 0, box_title.texture.width, box_title.texture.height)
dest = ray.Rectangle(final_x + 25, y + 20, box_title.texture.width, box_title.texture.height)
box_title.draw(src, dest, ray.Vector2(0, 0), 0, color)
else:
box_title = self.box_titles[i][0]
src = ray.Rectangle(0, 0, box_title.texture.width, box_title.texture.height)
dest = ray.Rectangle(final_x + 20, y + 20, box_title.texture.width, box_title.texture.height)
box_title.draw(src, dest, ray.Vector2(0, 0), 0, color)
if not self.cloud_texture_change.is_finished:
return
self.box_manager.draw()
def draw(self):
self.draw_background()
if self.state == State.SELECT_SIDE:
self.draw_side_select(self.side_select_fade.attribute)
elif self.state == State.SELECT_MODE:
if self.fade_out is not None:
self.draw_mode_select(self.fade_out.attribute)
else:
self.draw_mode_select(1.0)
self.draw_mode_select()
self.draw_footer()
ray.draw_texture(self.textures['entry'][320], 0, 0, ray.WHITE)
tex.draw_texture('global', 'player_entry')
if self.fade_out is not None and self.fade_out.is_finished:
src = ray.Rectangle(0, 0, self.texture_black.width, self.texture_black.height)
dest = ray.Rectangle(0, 0, self.width, self.height)
ray.draw_texture_pro(self.texture_black, src, dest, ray.Vector2(0, 0), 0, ray.WHITE)
if self.box_manager.is_finished():
ray.draw_rectangle(0, 0, self.width, self.height, ray.BLACK)
def draw_3d(self):
pass
class Box:
def __init__(self, text: tuple[OutlinedText, OutlinedText], location: str):
self.text, self.text_highlight = text
self.location = location
self.box_tex_obj = tex.textures['mode_select']['box']
if isinstance(self.box_tex_obj.texture, list):
raise Exception("Box texture cannot be iterable")
self.texture = self.box_tex_obj.texture
self.x = self.box_tex_obj.x
self.y = self.box_tex_obj.y
self.move = tex.get_animation(10)
self.open = tex.get_animation(11)
self.is_selected = False
self.moving_left = False
self.moving_right = False
def set_positions(self, x: int):
self.x = x
self.static_x = self.x
self.left_x = self.x
self.static_left = self.left_x
self.right_x = self.left_x + tex.textures['mode_select']['box'].width - tex.textures['mode_select']['box_highlight_right'].width
self.static_right = self.right_x
def update(self, current_time_ms: float, is_selected: bool):
self.move.update(current_time_ms)
if self.moving_left:
self.x = self.static_x - int(self.move.attribute)
elif self.moving_right:
self.x = self.static_x + int(self.move.attribute)
if self.move.is_finished:
self.moving_left = False
self.moving_right = False
self.static_x = self.x
if is_selected and not self.is_selected:
self.open.start()
self.is_selected = is_selected
if self.is_selected:
self.left_x = self.static_left - int(self.open.attribute)
self.right_x = self.static_right + int(self.open.attribute)
self.open.update(current_time_ms)
def move_left(self):
if not self.move.is_started:
self.move.start()
self.moving_left = True
def move_right(self):
if not self.move.is_started:
self.move.start()
self.moving_right = True
def _draw_highlighted(self, color):
texture_left = tex.textures['mode_select']['box_highlight_left'].texture
texture_center = tex.textures['mode_select']['box_highlight_center'].texture
texture_right = tex.textures['mode_select']['box_highlight_right'].texture
if isinstance(texture_center, list) or isinstance(texture_left, list):
raise Exception("highlight textures cannot be iterable")
center_src = ray.Rectangle(0, 0, texture_center.width, texture_center.height)
center_dest = ray.Rectangle(self.left_x + texture_left.width, self.y, self.right_x - self.left_x, texture_center.height)
ray.draw_texture_pro(texture_center, center_src, center_dest, ray.Vector2(0, 0), 0, color)
ray.draw_texture(texture_center, self.left_x, self.y, color)
ray.draw_texture(texture_left, self.left_x, self.y, color)
ray.draw_texture(texture_right, self.right_x, self.y, color)
def _draw_text(self, color):
text_x = self.x + (self.texture.width//2) - (self.text.texture.width//2)
text_y = self.y + 20
text_dest = ray.Rectangle(text_x, text_y, self.text.texture.width, self.text.texture.height)
if self.is_selected:
self.text_highlight.draw(self.text.default_src, text_dest, ray.Vector2(0, 0), 0, color)
else:
self.text.draw(self.text.default_src, text_dest, ray.Vector2(0, 0), 0, color)
def draw(self, fade: float):
color = ray.fade(ray.WHITE, fade)
ray.draw_texture(self.texture, self.x, self.y, color)
if self.is_selected and self.move.is_finished:
self._draw_highlighted(color)
self._draw_text(color)
class BoxManager:
def __init__(self):
self.box_titles: list[tuple[OutlinedText, OutlinedText]] = [
(OutlinedText('演奏ゲーム', 50, ray.WHITE, ray.Color(109, 68, 24, 255), outline_thickness=5, vertical=True),
OutlinedText('演奏ゲーム', 50, ray.WHITE, ray.BLACK, outline_thickness=5, vertical=True)),
(OutlinedText('ゲーム設定', 50, ray.WHITE, ray.Color(109, 68, 24, 255), outline_thickness=5, vertical=True),
OutlinedText('ゲーム設定', 50, ray.WHITE, ray.BLACK, outline_thickness=5, vertical=True))]
self.box_locations = ["SONG_SELECT", "SETTINGS"]
self.num_boxes = len(self.box_titles)
self.boxes = [Box(self.box_titles[i], self.box_locations[i]) for i in range(len(self.box_titles))]
self.selected_box_index = 0
self.fade_out = tex.get_animation(9)
spacing = 80
box_width = self.boxes[0].texture.width
total_width = self.num_boxes * box_width + (self.num_boxes - 1) * spacing
start_x = 640 - total_width//2
for i, box in enumerate(self.boxes):
box.set_positions(start_x + i * (box_width + spacing))
if i > 0:
box.move_right()
def select_box(self):
self.fade_out.start()
def is_box_selected(self):
return self.fade_out.is_started
def is_finished(self):
return self.fade_out.is_finished
def selected_box(self):
return self.boxes[self.selected_box_index].location
def move_left(self):
prev_selection = self.selected_box_index
if self.boxes[prev_selection].move.is_started and not self.boxes[prev_selection].move.is_finished:
return
self.selected_box_index = max(0, self.selected_box_index - 1)
if prev_selection == self.selected_box_index:
return
if self.selected_box_index != self.selected_box_index - 1:
self.boxes[self.selected_box_index+1].move_right()
self.boxes[self.selected_box_index].move_right()
def move_right(self):
prev_selection = self.selected_box_index
if self.boxes[prev_selection].move.is_started and not self.boxes[prev_selection].move.is_finished:
return
self.selected_box_index = min(self.num_boxes - 1, self.selected_box_index + 1)
if prev_selection == self.selected_box_index:
return
if self.selected_box_index != 0:
self.boxes[self.selected_box_index-1].move_left()
self.boxes[self.selected_box_index].move_left()
def update(self, current_time_ms: float):
self.fade_out.update(current_time_ms)
for i, box in enumerate(self.boxes):
is_selected = i == self.selected_box_index
box.update(current_time_ms, is_selected)
def draw(self):
for box in self.boxes:
box.draw(self.fade_out.attribute)

98
scenes/game.py
View File

@@ -11,6 +11,7 @@ from libs.animation import Animation
from libs.audio import audio
from libs.backgrounds import Background
from libs.tja import Balloon, Drumroll, Note, TJAParser, calculate_base_score
from libs.transition import Transition
from libs.utils import (
OutlinedText,
get_current_ms,
@@ -138,7 +139,9 @@ class GameScreen:
subtitle = self.tja.metadata.subtitle.get(global_data.config['general']['language'].lower(), '')
else:
subtitle = ''
self.transition = Transition(self.height, session_data.song_title, subtitle)
self.transition = Transition(session_data.song_title, subtitle)
self.transition.is_second = True
self.transition.start()
def on_screen_end(self, next_screen):
self.screen_init = False
@@ -236,7 +239,7 @@ class GameScreen:
if self.song_info is not None:
self.song_info.draw(self)
if self.transition is not None:
self.transition.draw(self.height)
self.transition.draw()
if self.result_transition is not None:
self.result_transition.draw(self.width, self.height, global_data.textures['shutter'][0], global_data.textures['shutter'][1])
@@ -764,9 +767,13 @@ class Judgement:
self.curr_hit_ms = str(round(ms_display, 2))
self.fade_animation_1 = Animation.create_fade(132, initial_opacity=0.5, delay=100)
self.fade_animation_1.start()
self.fade_animation_2 = Animation.create_fade(316 - 233.3, delay=233.3)
self.fade_animation_2.start()
self.move_animation = Animation.create_move(83, total_distance=15, start_position=144)
self.move_animation.start()
self.texture_animation = Animation.create_texture_change(100, textures=[(33, 50, 1), (50, 83, 2), (83, 100, 3), (100, float('inf'), 4)])
self.texture_animation.start()
def update(self, current_ms):
self.fade_animation_1.update(current_ms)
@@ -811,6 +818,7 @@ class LaneHitEffect:
self.type = type
self.color = ray.fade(ray.WHITE, 0.5)
self.fade = Animation.create_fade(150, delay=83, initial_opacity=0.5)
self.fade.start()
self.is_finished = False
def update(self, current_ms: float):
@@ -835,6 +843,7 @@ class DrumHitEffect:
self.color = ray.fade(ray.WHITE, 1)
self.is_finished = False
self.fade = Animation.create_fade(100, delay=67)
self.fade.start()
def update(self, current_ms: float):
self.fade.update(current_ms)
@@ -861,10 +870,15 @@ class GaugeHitEffect:
self.note_texture = note_texture
self.is_big = big
self.texture_change = Animation.create_texture_change(116.67, textures=[(0, 33.33, 1), (33.33, 66.66, 2), (66.66, float('inf'), 3)])
self.texture_change.start()
self.circle_fadein = Animation.create_fade(133, initial_opacity=0.0, final_opacity=1.0, delay=16.67)
self.circle_fadein.start()
self.resize = Animation.create_texture_resize(233, delay=self.texture_change.duration, initial_size=0.75, final_size=1.15)
self.resize.start()
self.fade_out = Animation.create_fade(66, delay=233)
self.fade_out.start()
self.test = Animation.create_fade(300, delay=116.67, initial_opacity=0.0, final_opacity=1.0)
self.test.start()
self.color = ray.fade(ray.YELLOW, self.circle_fadein.attribute)
self.is_finished = False
def update(self, current_ms):
@@ -1000,7 +1014,9 @@ class DrumrollCounter:
self.total_duration = 1349
self.drumroll_count = 0
self.fade_animation = Animation.create_fade(166, delay=self.total_duration - 166)
self.fade_animation.start()
self.stretch_animation = Animation.create_text_stretch(0)
self.stretch_animation.start()
def update_count(self, count: int, elapsed_time: float):
self.total_duration = elapsed_time + 1349
@@ -1008,6 +1024,7 @@ class DrumrollCounter:
if self.drumroll_count != count:
self.drumroll_count = count
self.stretch_animation = Animation.create_text_stretch(50)
self.stretch_animation.start()
def update(self, game_screen: GameScreen, current_ms: float, drumroll_count: int):
self.stretch_animation.update(current_ms)
@@ -1040,12 +1057,15 @@ class BalloonAnimation:
self.balloon_total = balloon_total
self.is_popped = False
self.fade_animation = Animation.create_fade(166)
self.fade_animation.start()
self.stretch_animation = Animation.create_text_stretch(0)
self.stretch_animation.start()
def update_count(self, balloon_count: int):
if self.balloon_count != balloon_count:
self.balloon_count = balloon_count
self.stretch_animation = Animation.create_text_stretch(50)
self.stretch_animation.start()
def update(self, game_screen: GameScreen, current_ms: float, balloon_count: int, is_popped: bool):
self.update_count(balloon_count)
@@ -1084,6 +1104,7 @@ class Combo:
def __init__(self, combo: int, current_ms: float):
self.combo = combo
self.stretch_animation = Animation.create_text_stretch(0)
self.stretch_animation.start()
self.color = [ray.fade(ray.WHITE, 1), ray.fade(ray.WHITE, 1), ray.fade(ray.WHITE, 1)]
self.glimmer_dict = {0: 0, 1: 0, 2: 0}
self.total_time = 250
@@ -1098,6 +1119,7 @@ class Combo:
if self.combo != combo:
self.combo = combo
self.stretch_animation = Animation.create_text_stretch(50)
self.stretch_animation.start()
def update(self, game_screen: GameScreen, current_ms: float, combo: int):
self.update_count(current_ms, combo)
@@ -1149,11 +1171,13 @@ class ScoreCounter:
def __init__(self, score: int):
self.score = score
self.stretch_animation = Animation.create_text_stretch(0)
self.stretch_animation.start()
def update_count(self, current_ms: float, score: int):
if self.score != score:
self.score = score
self.stretch_animation = Animation.create_text_stretch(50)
self.stretch_animation.start()
def update(self, current_ms: float, score: int):
self.update_count(current_ms, score)
@@ -1175,11 +1199,17 @@ class ScoreCounterAnimation:
def __init__(self, counter: int):
self.counter = counter
self.fade_animation_1 = Animation.create_fade(50, initial_opacity=0.0, final_opacity=1.0)
self.fade_animation_1.start()
self.move_animation_1 = Animation.create_move(80, total_distance=-20, start_position=175)
self.move_animation_1.start()
self.fade_animation_2 = Animation.create_fade(80, delay=366.74)
self.fade_animation_2.start()
self.move_animation_2 = Animation.create_move(66, total_distance=5, start_position=145, delay=80)
self.move_animation_2.start()
self.move_animation_3 = Animation.create_move(66, delay=279.36, total_distance=-2, start_position=146)
self.move_animation_3.start()
self.move_animation_4 = Animation.create_move(80, delay=366.74, total_distance=10, start_position=148)
self.move_animation_4.start()
self.color = ray.fade(ray.Color(254, 102, 0, 255), 1.0)
self.is_finished = False
@@ -1236,8 +1266,11 @@ class SongInfo:
song_name, 40, ray.Color(255, 255, 255, 255), ray.Color(0, 0, 0, 255), outline_thickness=5
)
self.fade_in = Animation.create_fade(self.FADE_DURATION, initial_opacity=0.0, final_opacity=1.0)
self.fade_in.start()
self.fade_out = Animation.create_fade(self.FADE_DURATION, delay=self.DISPLAY_DURATION)
self.fade_out.start()
self.fade_fake = Animation.create_fade(0, delay=self.DISPLAY_DURATION*2 + self.FADE_DURATION)
self.fade_fake.start()
def update(self, current_ms: float):
self.fade_in.update(current_ms)
@@ -1256,8 +1289,11 @@ class SongInfo:
def _reset_animations(self, current_ms: float):
self.fade_in = Animation.create_fade(self.FADE_DURATION, initial_opacity=0.0, final_opacity=1.0)
self.fade_in.start()
self.fade_out = Animation.create_fade(self.FADE_DURATION, delay=self.DISPLAY_DURATION)
self.fade_out.start()
self.fade_fake = Animation.create_fade(0, delay=self.DISPLAY_DURATION*2 + self.FADE_DURATION)
self.fade_fake.start()
def draw(self, game_screen: GameScreen):
song_texture_index = (global_data.songs_played % 4) + 8
@@ -1273,62 +1309,10 @@ class SongInfo:
dest = ray.Rectangle(text_x, text_y, self.song_title.texture.width, self.song_title.texture.height)
self.song_title.draw(src, dest, ray.Vector2(0, 0), 0, self.song_name_fade)
class Transition:
def __init__(self, screen_height: int, title: str, subtitle: str) -> None:
duration = 266
self.is_finished = False
self.rainbow_up = Animation.create_move(duration, start_position=0, total_distance=screen_height + global_data.textures['scene_change_rainbow'][2].height, ease_in='cubic')
self.chara_down = None
self.title = OutlinedText(title, 40, ray.WHITE, ray.BLACK, outline_thickness=5)
self.subtitle = OutlinedText(subtitle, 30, ray.WHITE, ray.BLACK, outline_thickness=5)
self.song_info_fade = Animation.create_fade(duration/2)
def update(self, current_time_ms: float):
self.rainbow_up.update(current_time_ms)
self.song_info_fade.update(current_time_ms)
if self.rainbow_up.is_finished and self.chara_down is None:
self.chara_down = Animation.create_move(33, start_position=0, total_distance=30)
if self.chara_down is not None:
self.chara_down.update(current_time_ms)
self.is_finished = self.chara_down.is_finished
def draw_song_info(self):
texture = global_data.textures['scene_change_rainbow'][6]
y = 720//2 - texture.height
src = ray.Rectangle(0, 0, texture.width, texture.height)
dest = ray.Rectangle(1280//2 - (texture.width*3)//2, y, texture.width*3, texture.height*2)
ray.draw_texture_pro(texture, src, dest, ray.Vector2(0, 0), 0, ray.fade(ray.WHITE, min(0.70, self.song_info_fade.attribute)))
texture = self.title.texture
y = 720//2 - texture.height//2 - 20
src = ray.Rectangle(0, 0, texture.width, texture.height)
dest = ray.Rectangle(1280//2 - texture.width//2, y, texture.width, texture.height)
self.title.draw(src, dest, ray.Vector2(0, 0), 0, ray.fade(ray.WHITE, self.song_info_fade.attribute))
texture = self.subtitle.texture
src = ray.Rectangle(0, 0, texture.width, texture.height)
dest = ray.Rectangle(1280//2 - texture.width//2, y + 50, texture.width, texture.height)
self.subtitle.draw(src, dest, ray.Vector2(0, 0), 0, ray.fade(ray.WHITE, self.song_info_fade.attribute))
def draw(self, screen_height: int):
ray.draw_texture(global_data.textures['scene_change_rainbow'][1], 0, screen_height - int(self.rainbow_up.attribute), ray.WHITE)
texture = global_data.textures['scene_change_rainbow'][0]
src = ray.Rectangle(0, 0, texture.width, texture.height)
dest = ray.Rectangle(0, -int(self.rainbow_up.attribute), texture.width, screen_height)
ray.draw_texture_pro(texture, src, dest, ray.Vector2(0, 0), 0, ray.WHITE)
texture = global_data.textures['scene_change_rainbow'][3]
offset = 0
if self.chara_down is not None:
offset = int(self.chara_down.attribute)
ray.draw_texture(global_data.textures['scene_change_rainbow'][4], 142, 14 -int(self.rainbow_up.attribute*3) - offset, ray.WHITE)
ray.draw_texture(global_data.textures['scene_change_rainbow'][5], 958, 144 -int(self.rainbow_up.attribute*3) - offset, ray.WHITE)
ray.draw_texture(texture, 76, -int(self.rainbow_up.attribute*3) - offset, ray.WHITE)
self.draw_song_info()
class ResultTransition:
def __init__(self, screen_height: int):
self.move = Animation.create_move(983.33, start_position=0, total_distance=screen_height//2, ease_out='quadratic')
self.move.start()
self.is_finished = False
@@ -1409,6 +1393,7 @@ class Gauge:
def add_good(self):
self.gauge_update_anim = Animation.create_fade(450)
self.gauge_update_anim.start()
self.previous_length = int(self.gauge_length)
self.gauge_length += (1 / self.total_notes) * (100 * (self.clear_start[self.difficulty] / self.table[self.difficulty][self.level]["clear_rate"]))
if self.gauge_length > 87:
@@ -1416,6 +1401,7 @@ class Gauge:
def add_ok(self):
self.gauge_update_anim = Animation.create_fade(450)
self.gauge_update_anim.start()
self.previous_length = int(self.gauge_length)
self.gauge_length += ((1 * self.table[self.difficulty][self.level]["ok_multiplier"]) / self.total_notes) * (100 * (self.clear_start[self.difficulty] / self.table[self.difficulty][self.level]["clear_rate"]))
if self.gauge_length > 87:
@@ -1430,6 +1416,7 @@ class Gauge:
def update(self, current_ms: float, good_count: int, ok_count: int, bad_count: int, total_notes: int):
if self.gauge_length == 87 and self.rainbow_fade_in is None:
self.rainbow_fade_in = Animation.create_fade(450, initial_opacity=0.0, final_opacity=1.0)
self.rainbow_fade_in.start()
if self.gauge_update_anim is not None:
self.gauge_update_anim.update(current_ms)
@@ -1441,6 +1428,7 @@ class Gauge:
if self.rainbow_animation is None:
self.rainbow_animation = Animation.create_texture_change((16.67*8) * 3, textures=[((16.67 * 3) * i, (16.67 * 3) * (i + 1), i) for i in range(8)])
self.rainbow_animation.start()
else:
self.rainbow_animation.update(current_ms)
if self.rainbow_animation.is_finished or self.gauge_length < 87:

12
scenes/loading.py
View File

@@ -1,11 +1,11 @@
import threading
from pathlib import Path
import pyray as ray
from libs.animation import Animation
from libs.song_hash import build_song_hashes
from libs.utils import get_current_ms, global_data, load_all_textures_from_zip
from libs.texture import tex
from libs.utils import get_current_ms, global_data
from scenes.song_select import SongSelectScreen
@@ -29,8 +29,6 @@ class LoadScreen:
self.loading_thread = None
self.navigator_thread = None
self.textures = load_all_textures_from_zip(Path('Graphics/lumendata/attract/kidou.zip'))
self.fade_in = None
def _load_song_hashes(self):
@@ -53,6 +51,7 @@ class LoadScreen:
def on_screen_start(self):
if not self.screen_init:
tex.load_screen_textures('loading')
self.loading_thread = threading.Thread(target=self._load_song_hashes)
self.loading_thread.daemon = True
self.loading_thread.start()
@@ -60,7 +59,7 @@ class LoadScreen:
def on_screen_end(self, next_screen: str):
self.screen_init = False
tex.unload_textures()
if self.loading_thread and self.loading_thread.is_alive():
self.loading_thread.join(timeout=1.0)
if self.navigator_thread and self.navigator_thread.is_alive():
@@ -79,6 +78,7 @@ class LoadScreen:
if self.loading_complete and self.fade_in is None:
self.fade_in = Animation.create_fade(1000, initial_opacity=0.0, final_opacity=1.0, ease_in='cubic')
self.fade_in.start()
if self.fade_in is not None:
self.fade_in.update(get_current_ms())
@@ -87,7 +87,7 @@ class LoadScreen:
def draw(self):
ray.draw_rectangle(0, 0, self.width, self.height, ray.BLACK)
ray.draw_texture(self.textures['kidou'][1], self.width//2 - self.textures['kidou'][1].width//2, 50, ray.WHITE)
tex.draw_texture('kidou', 'warning')
# Draw progress bar background
ray.draw_rectangle(

19
scenes/result.py
View File

@@ -142,6 +142,7 @@ class ResultScreen:
if self.score_delay is not None:
if get_current_ms() > self.score_delay and self.fade_in_bottom is None:
self.fade_in_bottom = Animation.create_fade(333, initial_opacity=0.0, final_opacity=1.0)
self.fade_in_bottom.start()
if self.gauge is not None:
self.state = self.gauge.state
@@ -258,10 +259,15 @@ class Crown:
def __init__(self):
duration = 466
self.resize = Animation.create_texture_resize(duration, initial_size=3.5, final_size=0.90, ease_in='quadratic')
self.resize.start()
self.resize_fix = Animation.create_texture_resize(216, initial_size=self.resize.final_size, final_size=1.0, delay=self.resize.duration)
self.resize_fix.start()
self.white_fadein = Animation.create_fade(133, initial_opacity=0.0, final_opacity=1.0, delay=self.resize.duration + self.resize_fix.duration, reverse_delay=0)
self.white_fadein.start()
self.gleam = Animation.create_texture_change(400, textures=[(0, 200, 0), (200, 250, 127), (250, 300, 128), (300, 350, 129), (350, 400, 0)], delay=self.resize.duration + self.resize_fix.duration + self.white_fadein.duration)
self.gleam.start()
self.fadein = Animation.create_fade(duration, initial_opacity=0.0, final_opacity=1.0, ease_in='quadratic')
self.fadein.start()
self.sound = audio.load_sound(Path('Sounds/result/SE_RESULT [1].ogg'))
self.sound_played = False
@@ -303,12 +309,16 @@ class BottomCharacters:
self.char_1_index = 339
self.char_2_index = 340
self.c_bounce_up = Animation.create_move(266, total_distance=40, ease_in='quadratic')
self.c_bounce_up.start()
self.c_bounce_down = Animation.create_move(266, total_distance=40, ease_out='quadratic', delay=self.c_bounce_up.duration)
self.c_bounce_down.start()
self.is_finished = False
def start(self):
self.move_up = Animation.create_move(366, total_distance=380, ease_out='cubic')
self.move_up.start()
self.move_down = Animation.create_move(133, total_distance=30, ease_out='cubic', delay=self.move_up.duration-5)
self.move_down.start()
def update(self, state):
self.state = state
@@ -317,10 +327,14 @@ class BottomCharacters:
self.char_2_index = 346
if self.bounce_up is None:
self.bounce_up = Animation.create_move(266, total_distance=40, ease_in='quadratic')
self.bounce_up.start()
self.bounce_down = Animation.create_move(266, total_distance=40, ease_out='quadratic', delay=self.bounce_up.duration)
self.bounce_down.start()
self.move_center = Animation.create_move(266, total_distance=450, ease_out='quadratic', delay=self.bounce_down.duration+self.bounce_up.duration)
self.move_center.start()
if self.flower_up is None:
self.flower_up = Animation.create_move(333, total_distance=365, ease_out='quadratic')
self.flower_up.start()
self.flower_start = get_current_ms()
elif self.state == State.FAIL:
self.char_1_index = 347
@@ -384,6 +398,7 @@ class BottomCharacters:
class FadeIn:
def __init__(self):
self.fadein = Animation.create_fade(450, initial_opacity=1.0, final_opacity=0.0, delay=100)
self.fadein.start()
self.fade = ray.fade(ray.WHITE, self.fadein.attribute)
self.is_finished = False
@@ -430,6 +445,7 @@ class Gauge:
self.gauge_length = gauge_length
self.rainbow_animation = None
self.gauge_fade_in = Animation.create_fade(366, initial_opacity=0.0, final_opacity=1.0)
self.gauge_fade_in.start()
self.is_finished = self.gauge_fade_in.is_finished
if self.gauge_length == 87:
self.state = State.RAINBOW
@@ -440,10 +456,12 @@ class Gauge:
def _create_rainbow_anim(self, current_ms):
anim = Animation.create_texture_change((16.67*8) * 3, textures=[((16.67 * 3) * i, (16.67 * 3) * (i + 1), i) for i in range(8)])
anim.start()
return anim
def _create_anim(self, current_ms: float, init: float, final: float):
anim = Animation.create_fade(450, initial_opacity=init, final_opacity=final)
anim.start()
return anim
def update(self, current_ms: float):
@@ -493,6 +511,7 @@ class FadeOut:
def __init__(self) -> None:
self.texture = global_data.textures['scene_change_fade'][0]
self.fade_out = Animation.create_fade(1000, initial_opacity=0.0, final_opacity=1.0)
self.fade_out.start()
self.is_finished = False
def update(self, current_time_ms: float):
self.fade_out.update(current_time_ms)

1217
scenes/song_select.py
View File

File diff suppressed because it is too large Load Diff

228
scenes/title.py
View File

@@ -3,15 +3,13 @@ from pathlib import Path
import pyray as ray
from libs.animation import Animation
from libs.audio import audio
from libs.texture import tex
from libs.utils import (
get_current_ms,
global_data,
is_l_don_pressed,
is_r_don_pressed,
load_all_textures_from_zip,
load_texture_from_zip,
)
from libs.video import VideoPlayer
@@ -29,9 +27,7 @@ class TitleScreen:
self.op_video_list = [file for file in video_dir.glob("**/*.mp4")]
video_dir = Path(global_data.config["paths"]["video_path"]) / "attract_videos"
self.attract_video_list = [file for file in video_dir.glob("**/*.mp4")]
self.load_sounds()
self.screen_init = False
self.fade_out = None
def load_sounds(self):
sounds_dir = Path("Sounds")
@@ -41,32 +37,25 @@ class TitleScreen:
self.sound_bachi_hit = audio.load_sound(title_dir / "SE_ATTRACT_3.ogg")
self.sound_warning_message = audio.load_sound(title_dir / "VO_ATTRACT_3.ogg")
self.sound_warning_error = audio.load_sound(title_dir / "SE_ATTRACT_1.ogg")
self.sounds = [self.sound_bachi_swipe, self.sound_bachi_hit, self.sound_warning_message, self.sound_warning_error]
def load_textures(self):
self.textures = load_all_textures_from_zip(Path('Graphics/lumendata/attract/keikoku.zip'))
self.texture_black = load_texture_from_zip(Path('Graphics/lumendata/attract/movie.zip'), 'movie_img00000.png')
def on_screen_start(self):
if not self.screen_init:
self.screen_init = True
self.load_textures()
tex.load_screen_textures('title')
self.load_sounds()
self.state = State.OP_VIDEO
self.op_video = None
self.attract_video = None
self.warning_board = None
self.fade_out = tex.get_animation(13)
def on_screen_end(self) -> str:
if self.op_video is not None:
self.op_video.stop()
if self.attract_video is not None:
self.attract_video.stop()
for sound in self.sounds:
if audio.is_sound_playing(sound):
audio.stop_sound(sound)
for zip in self.textures:
for texture in self.textures[zip]:
ray.unload_texture(texture)
audio.unload_all_sounds()
tex.unload_textures()
self.screen_init = False
return "ENTRY"
@@ -82,7 +71,7 @@ class TitleScreen:
self.state = State.WARNING
elif self.state == State.WARNING:
if self.warning_board is None:
self.warning_board = WarningScreen(get_current_ms(), self)
self.warning_board = WarningScreen(get_current_ms())
self.warning_board.update(get_current_ms(), self)
if self.warning_board.is_finished:
self.state = State.ATTRACT_VIDEO
@@ -101,66 +90,59 @@ class TitleScreen:
def update(self):
self.on_screen_start()
if self.fade_out is not None:
self.fade_out.update(get_current_ms())
if self.fade_out.is_finished:
return self.on_screen_end()
self.fade_out.update(get_current_ms())
if self.fade_out.is_finished:
return self.on_screen_end()
self.scene_manager()
if is_l_don_pressed() or is_r_don_pressed():
self.fade_out = Animation.create_fade(1000, initial_opacity=0.0, final_opacity=1.0)
self.fade_out.start()
audio.play_sound(self.sound_don)
def draw(self):
if self.state == State.OP_VIDEO and self.op_video is not None:
self.op_video.draw()
elif self.state == State.WARNING and self.warning_board is not None:
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)
ray.draw_texture_pro(self.textures['keikoku'][0], bg_source, bg_dest, ray.Vector2(0,0), 0, ray.WHITE)
self.warning_board.draw(self)
tex.draw_texture('warning', 'background')
self.warning_board.draw()
elif self.state == State.ATTRACT_VIDEO and self.attract_video is not None:
self.attract_video.draw()
if self.fade_out is not None:
src = ray.Rectangle(0, 0, self.texture_black.width, self.texture_black.height)
dest = ray.Rectangle(0, 0, self.width, self.height)
ray.draw_texture_pro(self.texture_black, src, dest, ray.Vector2(0, 0), 0, ray.fade(ray.WHITE, self.fade_out.attribute))
tex.draw_texture('movie', 'background', color=ray.fade(ray.WHITE, self.fade_out.attribute))
def draw_3d(self):
pass
class WarningScreen:
class X:
DELAY = 4250
def __init__(self):
self.resize = Animation.create_texture_resize(166.67, initial_size=1.0, final_size=1.5, delay=self.DELAY, reverse_delay=0)
self.fadein = Animation.create_fade(166.67, delay=self.DELAY, initial_opacity=0.0, final_opacity=1.0, reverse_delay=166.67)
self.fadein_2 = Animation.create_fade(166.67, delay=self.DELAY + self.fadein.duration, initial_opacity=0.0, final_opacity=1.0)
self.resize = tex.get_animation(0)
self.resize.start()
self.fadein = tex.get_animation(1)
self.fadein.start()
self.fadein_2 = tex.get_animation(2)
self.fadein_2.start()
self.sound_played = False
def update(self, current_ms: float, sound, elapsed_time):
def update(self, current_ms: float, sound):
self.resize.update(current_ms)
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:
if self.resize.attribute > 1 and not self.sound_played:
audio.play_sound(sound)
self.sound_played = True
def draw(self, texture):
scale = self.resize.attribute
x_x = 150 + (texture.width//2) - ((texture.width * scale)//2)
x_y = 200 + (texture.height//2) - ((texture.height * scale)//2)
x_source = ray.Rectangle(0, 0, texture.width, texture.height)
x_dest = ray.Rectangle(x_x, x_y, texture.width*scale, texture.height*scale)
ray.draw_texture_pro(texture, x_source, x_dest, ray.Vector2(0,0), 0, ray.fade(ray.WHITE, self.fadein.attribute))
def draw_bg(self):
tex.draw_texture('warning', 'x_lightred', color=ray.fade(ray.WHITE, self.fadein_2.attribute))
def draw_fg(self):
tex.draw_texture('warning', 'x_red', color=ray.fade(ray.WHITE, self.fadein.attribute), scale=self.resize.attribute, center=True)
class BachiHit:
def __init__(self):
self.resize = Animation.create_texture_resize(233.34, initial_size=0.5, final_size=1.5)
self.fadein = Animation.create_fade(116.67, initial_opacity=0.0, final_opacity=1.0, reverse_delay=0)
self.resize = tex.get_animation(3)
self.fadein = tex.get_animation(4)
self.sound_played = False
@@ -168,83 +150,55 @@ class WarningScreen:
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.fadein.start()
self.resize.start()
self.resize.update(current_ms)
self.fadein.update(current_ms)
def draw(self, texture):
scale = self.resize.attribute
hit_x = 350 + (texture.width//2) - ((texture.width * scale)//2)
hit_y = 225 + (texture.height//2) - ((texture.height * scale)//2)
hit_source = ray.Rectangle(0, 0, texture.width, texture.height)
hit_dest = ray.Rectangle(hit_x, hit_y, texture.width*scale, texture.height*scale)
ray.draw_texture_pro(texture, hit_source, hit_dest, ray.Vector2(0,0), 0, ray.fade(ray.WHITE, self.fadein.attribute))
def draw(self):
tex.draw_texture('warning', 'bachi_hit', color=ray.fade(ray.WHITE, self.fadein.attribute), scale=self.resize.attribute, center=True)
if self.resize.attribute > 0 and self.sound_played:
tex.draw_texture('warning', 'bachi')
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.create_fade(50, delay=16.67, 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
def __init__(self):
self.shadow_fade = tex.get_animation(5)
self.chara_0_frame = tex.get_animation(7)
self.chara_1_frame = tex.get_animation(6)
self.chara_0_frame.start()
self.chara_1_frame.start()
self.saved_frame = 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.chara_1_frame.update(current_ms)
self.chara_0_frame.update(current_ms)
self.current_ms = current_ms
self.is_finished = True if self.character_index(1) == self.animation_sequence[-1][1] else False
if self.chara_1_frame.attribute != self.saved_frame:
self.saved_frame = self.chara_1_frame.attribute
if not self.shadow_fade.is_started:
self.shadow_fade.start()
else:
self.shadow_fade.restart()
self.is_finished = self.chara_1_frame.is_finished
def draw(self, fade: ray.Color, fade_2: ray.Color):
tex.draw_texture('warning', 'chara_0_shadow', color=fade_2)
tex.draw_texture('warning', 'chara_0', frame=self.chara_0_frame.attribute, color=fade)
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)
tex.draw_texture('warning', 'chara_1_shadow', color=fade_2)
if -1 < self.chara_1_frame.attribute-1 < 7:
tex.draw_texture('warning', 'chara_1', frame=self.chara_1_frame.attribute-1, color=ray.fade(ray.WHITE, self.shadow_fade.attribute))
tex.draw_texture('warning', 'chara_1', frame=self.chara_1_frame.attribute, color=fade)
class Board:
def __init__(self, screen_width, screen_height, texture):
#Move warning board down from top of screen
self.move_down = Animation.create_move(266.67, total_distance=screen_height + ((screen_height - texture.height)//2) + 20, start_position=-720)
#Move warning board up a little bit
self.move_up = Animation.create_move(116.67, start_position=92 + 20, delay=self.move_down.duration, total_distance =-30)
#And finally into its correct position
self.move_center = Animation.create_move(116.67, start_position=82, delay=self.move_down.duration + self.move_up.duration, total_distance=10)
def __init__(self):
self.move_down = tex.get_animation(10)
self.move_down.start()
self.move_up = tex.get_animation(11)
self.move_up.start()
self.move_center = tex.get_animation(12)
self.move_center.start()
self.y_pos = 0
def update(self, current_ms):
@@ -252,29 +206,29 @@ class WarningScreen:
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)
self.y_pos = self.move_center.attribute
elif self.move_down.is_finished:
self.y_pos = int(self.move_up.attribute)
self.y_pos = self.move_up.attribute
else:
self.y_pos = int(self.move_down.attribute)
self.y_pos = self.move_down.attribute
tex.update_attr('warning', 'warning_box', 'y', self.y_pos)
def draw(self, texture):
ray.draw_texture(texture, 0, self.y_pos, ray.WHITE)
def draw(self):
tex.draw_texture('warning', 'warning_box')
def __init__(self, current_ms: float, title_screen: TitleScreen):
def __init__(self, current_ms: float):
self.start_ms = current_ms
self.fade_in = Animation.create_fade(300, delay=266.67, initial_opacity=0.0, final_opacity=1.0)
self.fade_out = Animation.create_fade(500, delay=1000, initial_opacity=0.0, final_opacity=1.0)
self.fade_in = tex.get_animation(8)
self.fade_in.start()
self.fade_out = tex.get_animation(9)
self.fade_out.start()
self.board = self.Board(title_screen.width, title_screen.height, title_screen.textures['keikoku'][1])
self.board = self.Board()
self.warning_x = self.X()
self.warning_bachi_hit = self.BachiHit()
self.characters = self.Characters(current_ms, self.start_ms)
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.characters = self.Characters()
self.is_finished = False
@@ -284,8 +238,12 @@ class WarningScreen:
self.fade_out.update(current_ms)
delay = 566.67
elapsed_time = current_ms - self.start_ms
self.warning_x.update(current_ms, title_screen.sound_warning_error, elapsed_time)
self.warning_x.update(current_ms, title_screen.sound_warning_error)
self.characters.update(current_ms)
tex.update_attr('warning', 'chara_0', 'y', self.board.y_pos)
tex.update_attr('warning', 'chara_0_shadow', 'y', self.board.y_pos)
tex.update_attr('warning', 'chara_1_shadow', 'y', self.board.y_pos)
tex.update_attr('warning', 'chara_1', 'y', self.board.y_pos)
if self.characters.is_finished:
self.warning_bachi_hit.update(current_ms, title_screen.sound_bachi_hit)
@@ -297,16 +255,14 @@ class WarningScreen:
self.is_finished = self.fade_out.is_finished
def draw(self, title_screen: TitleScreen):
def draw(self):
fade = ray.fade(ray.WHITE, self.fade_in.attribute)
fade_2 = ray.fade(ray.WHITE, self.fade_in.attribute if self.fade_in.attribute < 0.75 else 0.75)
self.board.draw(title_screen.textures['keikoku'][1])
ray.draw_texture(title_screen.textures['keikoku'][15], 150, 200, ray.fade(ray.WHITE, self.warning_x.fadein_2.attribute))
fade_2 = ray.fade(ray.WHITE, min(self.fade_in.attribute, 0.75))
self.characters.draw(title_screen.textures, fade, fade_2, self.board.y_pos)
self.board.draw()
self.warning_x.draw_bg()
self.characters.draw(fade, fade_2)
self.warning_x.draw_fg()
self.warning_bachi_hit.draw()
self.warning_x.draw(title_screen.textures['keikoku'][14])
self.warning_bachi_hit.draw(title_screen.textures['keikoku'][18])
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))
tex.draw_texture('movie', 'background', color=ray.fade(ray.WHITE, self.fade_out.attribute))