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 animation restart method and new backgrounds

Browse Source 
This commit adds a new `restart()` method to animation classes to properly
reset their state, avoiding the need to recreate animations. It also adds
several new background variations and improves background selection.
This commit is contained in:
Yonokid
2025-06-18 23:11:17 -04:00
parent 6c8cdb9fad
commit c1081d255b
8 changed files with 354 additions and 68 deletions
Download Patch File Download Diff File Expand all files Collapse all files

88
scenes/entry.py
View File

@@ -13,6 +13,7 @@ from libs.utils import (
is_r_don_pressed,
is_r_kat_pressed,
load_all_textures_from_zip,
load_texture_from_zip,
)
@@ -32,6 +33,7 @@ class EntryScreen:
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:
@@ -42,6 +44,7 @@ class EntryScreen:
sounds_dir = Path("Sounds")
self.sound_don = audio.load_sound(sounds_dir / "inst_00_don.wav")
self.sound_kat = audio.load_sound(sounds_dir / "inst_00_katsu.wav")
self.bgm = audio.load_sound(sounds_dir / "entry" / "JINGLE_ENTRY [1].ogg")
def on_screen_start(self):
if not self.screen_init:
@@ -58,14 +61,21 @@ class EntryScreen:
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)
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)
return next_screen
def handle_input(self):
if self.fade_out is not None:
return
if self.state == State.SELECT_SIDE:
if is_l_don_pressed() or is_r_don_pressed():
if self.side == 1:
@@ -89,10 +99,7 @@ class EntryScreen:
elif self.state == State.SELECT_MODE:
if is_l_don_pressed() or is_r_don_pressed():
audio.play_sound(self.sound_don)
if self.selected_box == 0:
return self.on_screen_end("SONG_SELECT")
elif self.selected_box == 1:
return self.on_screen_end("SETTINGS")
self.fade_out = Animation.create_fade(160)
if is_l_kat_pressed():
audio.play_sound(self.sound_kat)
self.selected_box = max(0, self.selected_box - 1)
@@ -102,6 +109,10 @@ class EntryScreen:
def update(self):
self.on_screen_start()
self.side_select_fade.update(get_current_ms())
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:
@@ -117,6 +128,13 @@ class EntryScreen:
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")
return self.handle_input()
def draw_background(self):
@@ -130,7 +148,7 @@ class EntryScreen:
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, 0.50))
draw_scaled_texture(self.textures['entry'][374], -7, -15, 2.0, 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)
@@ -139,37 +157,38 @@ class EntryScreen:
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)
def draw_side_select(self):
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, ray.WHITE)
ray.draw_texture(self.textures['entry'][208], right_x, top_y, ray.WHITE)
ray.draw_texture(self.textures['entry'][204], left_x, bottom_y, ray.WHITE)
ray.draw_texture(self.textures['entry'][207], right_x, bottom_y, ray.WHITE)
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)
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, ray.WHITE)
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, ray.WHITE)
ray.draw_texture_pro(texture, src, dest, ray.Vector2(0, 0), 0, 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, ray.WHITE)
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, ray.WHITE)
ray.draw_texture_pro(texture, src, dest, ray.Vector2(0, 0), 0, 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, ray.WHITE)
ray.draw_texture_pro(texture, src, dest, ray.Vector2(0, 0), 0, color)
ray.draw_texture(self.textures['entry'][226], 384, 144, ray.WHITE)
ray.draw_texture(self.textures['entry'][226], 384, 144, color)
cursor_x = 261
cursor_texture = self.textures['entry'][230]
@@ -179,7 +198,7 @@ class EntryScreen:
flip = -1
else:
texture = self.textures['entry'][232]
ray.draw_texture(texture, 261, 400, ray.WHITE)
ray.draw_texture(texture, 261, 400, color)
if self.side == 1:
texture = self.textures['entry'][76]
@@ -187,19 +206,19 @@ class EntryScreen:
cursor_x = 512
else:
texture = self.textures['entry'][228]
ray.draw_texture(texture, 512, 400, ray.WHITE)
ray.draw_texture(self.textures['entry'][201], 512, 408, ray.WHITE)
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, ray.WHITE)
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, ray.WHITE)
ray.draw_texture_pro(cursor_texture, src, dest, ray.Vector2(0, 0), 0, color)
def draw_player_drum(self):
move_x = 0
@@ -230,8 +249,9 @@ class EntryScreen:
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)
def draw_mode_select(self):
def draw_mode_select(self, fade):
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
@@ -248,31 +268,39 @@ class EntryScreen:
else:
push_offset = push_distance
final_x = x_pos + push_offset
ray.draw_texture(self.textures['entry'][262], final_x, y, ray.WHITE)
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, ray.WHITE)
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, ray.WHITE)
ray.draw_texture(self.textures['entry'][303], final_x+100, y, ray.WHITE)
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 + 12, y + 20, box_title.texture.width, box_title.texture.height)
box_title.draw(src, dest, ray.Vector2(0, 0), 0, ray.WHITE)
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 + 9, y + 20, box_title.texture.width, box_title.texture.height)
box_title.draw(src, dest, ray.Vector2(0, 0), 0, ray.WHITE)
box_title.draw(src, dest, ray.Vector2(0, 0), 0, color)
def draw(self):
self.draw_background()
if self.state == State.SELECT_SIDE:
self.draw_side_select()
self.draw_side_select(self.side_select_fade.attribute)
elif self.state == State.SELECT_MODE:
self.draw_mode_select()
if self.fade_out is not None:
self.draw_mode_select(self.fade_out.attribute)
else:
self.draw_mode_select(1.0)
self.draw_footer()
ray.draw_texture(self.textures['entry'][320], 0, 0, ray.WHITE)
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)

48
scenes/game.py
View File

@@ -28,22 +28,18 @@ from libs.video import VideoPlayer
class GameScreen:
JUDGE_X = 414
SCREEN_WIDTH = 1280
SCREEN_HEIGHT = 720
def __init__(self, width: int, height: int):
self.width = width
self.height = height
self.current_ms = 0
self.result_transition = None
self.transition = None
self.song_info = None
self.screen_init = False
self.movie = None
self.end_ms = 0
self.start_delay = 1000
self.song_started = False
self.prev_touch_count = 0
self.background = Background(width, height)
def load_textures(self):
self.textures = load_all_textures_from_zip(Path('Graphics/lumendata/enso_system/common.zip'))
@@ -124,13 +120,15 @@ class GameScreen:
def on_screen_start(self):
if not self.screen_init:
self.screen_init = True
self.background = Background(self.width, self.height)
self.load_textures()
self.load_sounds()
self.init_tja(global_data.selected_song, session_data.selected_difficulty)
self.song_info = SongInfo(session_data.song_title, 'TEST')
self.result_transition = None
self.transition = Transition(self.height)
def on_screen_end(self):
def on_screen_end(self, next_screen):
self.screen_init = False
for zip in self.textures:
for texture in self.textures[zip]:
@@ -140,7 +138,7 @@ class GameScreen:
self.song_started = False
self.end_ms = 0
self.movie = None
return 'RESULT'
return next_screen
def write_score(self):
if global_data.config['general']['autoplay']:
@@ -167,6 +165,8 @@ class GameScreen:
def update(self):
self.on_screen_start()
if self.transition is not None:
self.transition.update(get_current_ms())
self.current_ms = get_current_ms() - self.start_ms
if (self.current_ms >= self.tja.metadata.offset*1000 + self.start_delay - global_data.config["general"]["judge_offset"]) and not self.song_started:
if self.song_music is not None:
@@ -188,7 +188,7 @@ class GameScreen:
if self.result_transition is not None:
self.result_transition.update(get_current_ms())
if self.result_transition.is_finished:
return self.on_screen_end()
return self.on_screen_end('RESULT')
elif len(self.player_1.play_notes) == 0:
session_data.result_score, session_data.result_good, session_data.result_ok, session_data.result_bad, session_data.result_max_combo, session_data.result_total_drumroll = self.player_1.get_result_score()
session_data.result_gauge_length = self.player_1.gauge.gauge_length
@@ -206,6 +206,10 @@ class GameScreen:
audio.play_sound(self.sound_restart)
self.song_started = False
if ray.is_key_pressed(ray.KeyboardKey.KEY_ESCAPE):
audio.stop_sound(self.song_music)
return self.on_screen_end('SONG_SELECT')
def draw(self):
if self.movie is not None:
self.movie.draw()
@@ -214,6 +218,8 @@ class GameScreen:
self.player_1.draw(self)
if self.song_info is not None:
self.song_info.draw(self)
if self.transition is not None:
self.transition.draw(self.height)
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])
@@ -1215,6 +1221,32 @@ 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) -> None:
self.is_finished = False
self.rainbow_up = Animation.create_move(266, start_position=0, total_distance=screen_height + global_data.textures['scene_change_rainbow'][2].height, ease_in='cubic')
self.chara_down = None
def update(self, current_time_ms: float):
self.rainbow_up.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(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(texture, 76, -int(self.rainbow_up.attribute*3) - offset, ray.WHITE)
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')

30
scenes/settings.py
View File

@@ -23,6 +23,7 @@ class SettingsScreen:
self.setting_index = 0
self.in_setting_edit = False
self.editing_key = False
self.editing_gamepad = False
self.temp_key_input = ""
def on_screen_start(self):
@@ -122,6 +123,23 @@ class SettingsScreen:
elif key_pressed == ray.KeyboardKey.KEY_ESCAPE:
self.editing_key = False
def handle_gamepad_binding(self, section, key):
self.editing_gamepad = True
self.temp_key_input = ""
def update_gamepad_binding(self):
"""Update gamepad binding based on input"""
button_pressed = ray.get_gamepad_button_pressed()
if button_pressed != 0:
current_header = self.headers[self.header_index]
settings = self.get_current_settings()
if settings:
setting_key, _ = settings[self.setting_index]
self.config[current_header][setting_key] = [button_pressed]
self.editing_gamepad = False
if ray.is_key_pressed(ray.KeyboardKey.KEY_ESCAPE):
self.editing_gamepad = False
def update(self):
self.on_screen_start()
@@ -130,6 +148,10 @@ class SettingsScreen:
self.update_key_binding()
return
if self.editing_gamepad:
self.update_gamepad_binding()
return
current_header = self.headers[self.header_index]
# Exit handling
@@ -166,14 +188,18 @@ class SettingsScreen:
elif isinstance(setting_value, (int, float)):
self.handle_numeric_change(current_header, setting_key, 1)
elif isinstance(setting_value, str):
if 'keybinds' in current_header:
if 'keys' in current_header:
self.handle_key_binding(current_header, setting_key)
elif 'gamepad' in current_header:
self.handle_gamepad_binding(current_header, setting_key)
else:
self.handle_string_cycle(current_header, setting_key)
elif isinstance(setting_value, list) and len(setting_value) > 0:
if isinstance(setting_value[0], str) and len(setting_value[0]) == 1:
# Key binding
self.handle_key_binding(current_header, setting_key)
elif isinstance(setting_value[0], int):
self.handle_gamepad_binding(current_header, setting_key)
elif is_l_don_pressed():
# Modify setting value (reverse direction for numeric)
setting_key, setting_value = settings[self.setting_index]
@@ -183,7 +209,7 @@ class SettingsScreen:
elif isinstance(setting_value, (int, float)):
self.handle_numeric_change(current_header, setting_key, -1)
elif isinstance(setting_value, str):
if 'keybinds' not in current_header:
if ('keys' not in current_header) and ('gamepad' not in current_header):
self.handle_string_cycle(current_header, setting_key)
elif ray.is_key_pressed(ray.KeyboardKey.KEY_ESCAPE):

15
scenes/song_select.py
View File

@@ -47,7 +47,7 @@ class SongSelectScreen:
self.sound_skip = audio.load_sound(sounds_dir / 'song_select' / 'Skip.ogg')
self.sound_ura_switch = audio.load_sound(sounds_dir / 'song_select' / 'SE_SELECT [4].ogg')
audio.set_sound_volume(self.sound_ura_switch, 0.25)
#self.sound_select = audio.load_sound(sounds_dir / "song_select.wav")
self.sound_bgm = audio.load_sound(sounds_dir / "song_select" / "JINGLE_GENRE [1].ogg")
#self.sound_cancel = audio.load_sound(sounds_dir / "cancel.wav")
def on_screen_start(self):
@@ -78,22 +78,25 @@ class SongSelectScreen:
if str(global_data.selected_song) in self.navigator.all_song_files:
self.navigator.mark_crowns_dirty_for_song(self.navigator.all_song_files[str(global_data.selected_song)])
def on_screen_end(self):
def on_screen_end(self, next_screen):
self.screen_init = False
global_data.selected_song = self.navigator.get_current_item().path
session_data.selected_difficulty = self.selected_difficulty
audio.unload_sound(self.sound_bgm)
self.reset_demo_music()
for zip in self.textures:
for texture in self.textures[zip]:
ray.unload_texture(texture)
return "GAME"
return next_screen
def reset_demo_music(self):
if self.demo_song is not None:
audio.stop_music_stream(self.demo_song)
audio.unload_music_stream(self.demo_song)
audio.play_sound(self.sound_bgm)
self.demo_song = None
self.navigator.get_current_item().box.wait = get_current_ms()
def handle_input(self):
if self.state == State.BROWSING:
if ray.is_key_pressed(ray.KeyboardKey.KEY_LEFT_CONTROL) or (is_l_kat_pressed() and get_current_ms() <= self.last_moved + 100):
@@ -205,7 +208,7 @@ class SongSelectScreen:
if self.game_transition is not None:
self.game_transition.update(get_current_ms())
if self.game_transition.is_finished:
return self.on_screen_end()
return self.on_screen_end("GAME")
else:
self.handle_input()
@@ -224,6 +227,7 @@ class SongSelectScreen:
audio.normalize_music_stream(self.demo_song, 0.1935)
audio.seek_music_stream(self.demo_song, song.tja.metadata.demostart)
audio.play_music_stream(self.demo_song)
audio.stop_sound(self.sound_bgm)
if song.box.is_open:
current_box = song.box
if current_box.texture_index != 552 and get_current_ms() >= song.box.wait + (83.33*3):
@@ -255,6 +259,9 @@ class SongSelectScreen:
if self.ura_switch_animation is not None:
self.ura_switch_animation.update(get_current_ms())
if ray.is_key_pressed(ray.KeyboardKey.KEY_ESCAPE):
return self.on_screen_end('ENTRY')
def draw_selector(self):
if self.selected_difficulty == -1:
ray.draw_texture(self.textures['song_select'][133], 314, 110, ray.WHITE)

16
scenes/title.py
View File

@@ -31,6 +31,7 @@ class TitleScreen:
self.attract_video_list = [file for file in video_dir.glob("**/*.mp4")]
self.load_sounds()
self.screen_init = False
self.fade_out = None
def get_videos(self):
return self.op_video, self.attract_video
@@ -38,7 +39,7 @@ class TitleScreen:
def load_sounds(self):
sounds_dir = Path("Sounds")
title_dir = sounds_dir / "title"
self.sound_don = audio.load_sound(sounds_dir / "inst_00_don.wav")
self.sound_bachi_swipe = audio.load_sound(title_dir / "SE_ATTRACT_2.ogg")
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")
@@ -99,9 +100,15 @@ 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.scene_manager()
if is_l_don_pressed() or is_r_don_pressed():
return self.on_screen_end()
self.fade_out = Animation.create_fade(1000, initial_opacity=0.0, final_opacity=1.0)
audio.play_sound(self.sound_don)
def draw(self):
if self.state == State.OP_VIDEO:
@@ -114,6 +121,11 @@ class TitleScreen:
elif self.state == State.ATTRACT_VIDEO:
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))
class WarningScreen:
class X:
DELAY = 4250