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

deworming my simulator

Browse Source
This commit is contained in:
Yonokid
2025-08-28 20:50:53 -04:00
parent 9da7ce7b95
commit 2bf7495020
13 changed files with 257 additions and 382 deletions
Download Patch File Download Diff File Expand all files Collapse all files

31
libs/animation.py
View File

@@ -15,7 +15,7 @@ def get_current_ms() -> int:
class BaseAnimation():
def __init__(self, duration: float, delay: float = 0.0) -> None:
def __init__(self, duration: float, delay: float = 0.0, loop: bool = False) -> None:
"""
Initialize a base animation.
@@ -31,6 +31,7 @@ class BaseAnimation():
self.is_finished = False
self.attribute = 0
self.is_started = False
self.loop = loop
def __repr__(self):
return str(self.__dict__)
@@ -40,6 +41,8 @@ class BaseAnimation():
def update(self, current_time_ms: float) -> None:
"""Update the animation based on the current time."""
if self.loop and self.is_finished:
self.restart()
def restart(self) -> None:
self.start_ms = get_current_ms()
@@ -87,11 +90,11 @@ class BaseAnimation():
return progress
class FadeAnimation(BaseAnimation):
def __init__(self, duration: float, initial_opacity: float = 1.0,
def __init__(self, duration: float, initial_opacity: float = 1.0, loop: bool = False,
final_opacity: float = 0.0, delay: float = 0.0,
ease_in: Optional[str] = None, ease_out: Optional[str] = None,
reverse_delay: Optional[float] = None) -> None:
super().__init__(duration, delay)
super().__init__(duration, delay=delay, loop=loop)
self.initial_opacity = initial_opacity
self.attribute = initial_opacity
self.final_opacity = final_opacity
@@ -112,6 +115,7 @@ class FadeAnimation(BaseAnimation):
def update(self, current_time_ms: float) -> None:
if not self.is_started:
return
super().update(current_time_ms)
elapsed_time = current_time_ms - self.start_ms
if elapsed_time <= self.delay:
@@ -134,11 +138,11 @@ class FadeAnimation(BaseAnimation):
self.attribute = self.initial_opacity + progress * (self.final_opacity - self.initial_opacity)
class MoveAnimation(BaseAnimation):
def __init__(self, duration: float, total_distance: int = 0,
def __init__(self, duration: float, total_distance: int = 0, loop: bool = False,
start_position: int = 0, delay: float = 0.0,
reverse_delay: Optional[float] = None,
ease_in: Optional[str] = None, ease_out: Optional[str] = None) -> None:
super().__init__(duration, delay)
super().__init__(duration, delay=delay, loop=loop)
self.reverse_delay = reverse_delay
self.reverse_delay_saved = reverse_delay
self.total_distance = total_distance
@@ -158,6 +162,7 @@ class MoveAnimation(BaseAnimation):
def update(self, current_time_ms: float) -> None:
if not self.is_started:
return
super().update(current_time_ms)
elapsed_time = current_time_ms - self.start_ms
if elapsed_time < self.delay:
self.attribute = self.start_position
@@ -178,8 +183,9 @@ class MoveAnimation(BaseAnimation):
self.attribute = self.start_position + (self.total_distance * progress)
class TextureChangeAnimation(BaseAnimation):
def __init__(self, duration: float, textures: list[tuple[float, float, int]], delay: float = 0.0) -> None:
super().__init__(duration)
def __init__(self, duration: float, textures: list[tuple[float, float, int]],
loop: bool = False, delay: float = 0.0) -> None:
super().__init__(duration, loop=loop)
self.textures = textures
self.delay = delay
self.delay_saved = delay
@@ -190,9 +196,9 @@ class TextureChangeAnimation(BaseAnimation):
self.attribute = self.textures[0][2]
def update(self, current_time_ms: float) -> None:
super().update(current_time_ms)
if not self.is_started:
return
super().update(current_time_ms)
elapsed_time = current_time_ms - self.start_ms
if elapsed_time < self.delay:
return
@@ -206,11 +212,12 @@ class TextureChangeAnimation(BaseAnimation):
self.is_finished = True
class TextStretchAnimation(BaseAnimation):
def __init__(self, duration: float) -> None:
super().__init__(duration)
def __init__(self, duration: float, loop: bool = False,) -> None:
super().__init__(duration, loop=loop)
def update(self, current_time_ms: float) -> None:
if not self.is_started:
return
super().update(current_time_ms)
elapsed_time = current_time_ms - self.start_ms
if elapsed_time <= self.duration:
self.attribute = 2 + 5 * (elapsed_time // 25)
@@ -223,10 +230,11 @@ class TextStretchAnimation(BaseAnimation):
class TextureResizeAnimation(BaseAnimation):
def __init__(self, duration: float, initial_size: float = 1.0,
loop: bool = False,
final_size: float = 0.0, delay: float = 0.0,
reverse_delay: Optional[float] = None,
ease_in: Optional[str] = None, ease_out: Optional[str] = None) -> None:
super().__init__(duration, delay)
super().__init__(duration, delay=delay, loop=loop)
self.initial_size = initial_size
self.final_size = final_size
self.reverse_delay = reverse_delay
@@ -249,6 +257,7 @@ class TextureResizeAnimation(BaseAnimation):
return
else:
self.is_started = not self.is_finished
super().update(current_time_ms)
elapsed_time = current_time_ms - self.start_ms
if elapsed_time <= self.delay:

356
libs/backgrounds.py
View File

@@ -1,22 +1,16 @@
import random
from pathlib import Path
import pyray as ray
from libs.animation import Animation
from libs.texture import TextureWrapper
from libs.utils import load_all_textures_from_zip
class Background:
def __init__(self, screen_width: int, screen_height: int, player_num: int):
self.screen_width = screen_width
self.screen_height = screen_height
def __init__(self, player_num: int):
self.tex_wrapper = TextureWrapper()
self.tex_wrapper.load_animations('background')
self.donbg = DonBG.create(self.tex_wrapper, self.screen_width, self.screen_height, random.randint(0, 5), player_num)
self.bg_normal = BGNormal.create(self.screen_width, self.screen_height, random.randint(1, 5))
self.bg_fever = BGFever.create(self.screen_width, self.screen_height, 4)
self.donbg = DonBG.create(self.tex_wrapper, random.randint(0, 5), player_num)
self.bg_normal = BGNormal.create(self.tex_wrapper, random.randint(0, 4))
self.bg_fever = BGFever.create(self.tex_wrapper, 3)
self.footer = Footer(self.tex_wrapper, random.randint(0, 2))
self.is_clear = False
def update(self, current_time_ms: float, is_clear: bool):
@@ -27,9 +21,9 @@ class Background:
self.bg_normal.update(current_time_ms)
self.bg_fever.update(current_time_ms)
def draw(self):
self.bg_normal.draw()
self.bg_normal.draw(self.tex_wrapper)
if self.is_clear:
self.bg_fever.draw()
self.bg_fever.draw(self.tex_wrapper)
self.footer.draw(self.tex_wrapper)
self.donbg.draw(self.tex_wrapper)
@@ -39,19 +33,16 @@ class Background:
class DonBG:
@staticmethod
def create(tex: TextureWrapper, screen_width: int, screen_height: int, index: int, player_num: int):
def create(tex: TextureWrapper, index: int, player_num: int):
map = [DonBG1, DonBG2, DonBG3, DonBG4, DonBG5, DonBG6]
selected_obj = map[index]
return selected_obj(tex, index, screen_width, screen_height, player_num)
return selected_obj(tex, index, player_num)
class DonBGBase:
def __init__(self, tex: TextureWrapper, index: int, screen_width: int, screen_height: int, player_num: int):
self.screen_width = screen_width
self.screen_height = screen_height
def __init__(self, tex: TextureWrapper, index: int, player_num: int):
self.name = f'{index}_{player_num}'
tex.load_zip('background', f'donbg/{self.name}')
self.move = tex.get_animation(0)
self.move.start()
self.is_clear = False
self.clear_fade = tex.get_animation(1)
@@ -61,19 +52,14 @@ class DonBGBase:
self.is_clear = is_clear
self.move.update(current_time_ms)
self.clear_fade.update(current_time_ms)
if self.move.is_finished:
self.move.restart()
class DonBG1(DonBGBase):
def __init__(self, tex: TextureWrapper, index: int, screen_width: int, screen_height: int, player_num: int):
super().__init__(tex, index, screen_width, screen_height, player_num)
def __init__(self, tex: TextureWrapper, index: int, player_num: int):
super().__init__(tex, index, player_num)
self.overlay_move = tex.get_animation(2)
self.overlay_move.start()
def update(self, current_time_ms: float, is_clear: bool):
super().update(current_time_ms, is_clear)
self.overlay_move.update(current_time_ms)
if self.overlay_move.is_finished:
self.overlay_move.restart()
def draw(self, tex: TextureWrapper):
self._draw_textures(tex, 1.0)
if self.is_clear:
@@ -87,15 +73,12 @@ class DonBG1(DonBGBase):
tex.draw_texture(self.name, 'footer', frame=self.is_clear, fade=fade, x=(i*56)+self.move.attribute*((56/328)*3), y=self.overlay_move.attribute)
class DonBG2(DonBGBase):
def __init__(self, tex: TextureWrapper, index: int, screen_width: int, screen_height: int, player_num: int):
super().__init__(tex, index, screen_width, screen_height, player_num)
def __init__(self, tex: TextureWrapper, index: int, player_num: int):
super().__init__(tex, index, player_num)
self.overlay_move = tex.get_animation(3)
self.overlay_move.start()
def update(self, current_time_ms: float, is_clear: bool):
super().update(current_time_ms, is_clear)
self.overlay_move.update(current_time_ms)
if self.overlay_move.is_finished:
self.overlay_move.restart()
def draw(self, tex: TextureWrapper):
self._draw_textures(tex, 1.0)
if self.is_clear:
@@ -106,16 +89,12 @@ class DonBG2(DonBGBase):
tex.draw_texture(self.name, 'overlay', frame=self.is_clear, fade=fade, x=(i*328)+self.move.attribute, y=self.overlay_move.attribute)
class DonBG3(DonBGBase):
def __init__(self, tex: TextureWrapper, index: int, screen_width: int, screen_height: int, player_num: int):
super().__init__(tex, index, screen_width, screen_height, player_num)
def __init__(self, tex: TextureWrapper, index: int, player_num: int):
super().__init__(tex, index, player_num)
self.bounce_up = tex.get_animation(4)
self.bounce_down = tex.get_animation(5)
self.overlay_move = tex.get_animation(6)
self.overlay_move_2 = tex.get_animation(7)
self.bounce_up.start()
self.bounce_down.start()
self.overlay_move.start()
self.overlay_move_2.start()
def update(self, current_time_ms: float, is_clear: bool):
super().update(current_time_ms, is_clear)
@@ -123,11 +102,6 @@ class DonBG3(DonBGBase):
self.bounce_down.update(current_time_ms)
self.overlay_move.update(current_time_ms)
self.overlay_move_2.update(current_time_ms)
if self.overlay_move_2.is_finished:
self.bounce_up.restart()
self.bounce_down.restart()
self.overlay_move.restart()
self.overlay_move_2.restart()
def draw(self, tex: TextureWrapper):
self._draw_textures(tex, 1.0)
@@ -142,15 +116,12 @@ class DonBG3(DonBGBase):
tex.draw_texture(self.name, 'overlay', frame=self.is_clear, fade=fade, x=(i*328)+(self.move.attribute*2), y=y)
class DonBG4(DonBGBase):
def __init__(self, tex: TextureWrapper, index: int, screen_width: int, screen_height: int, player_num: int):
super().__init__(tex, index, screen_width, screen_height, player_num)
def __init__(self, tex: TextureWrapper, index: int, player_num: int):
super().__init__(tex, index, player_num)
self.overlay_move = tex.get_animation(2)
self.overlay_move.start()
def update(self, current_time_ms: float, is_clear: bool):
super().update(current_time_ms, is_clear)
self.overlay_move.update(current_time_ms)
if self.overlay_move.is_finished:
self.overlay_move.restart()
def draw(self, tex: TextureWrapper):
self._draw_textures(tex, 1.0)
if self.is_clear:
@@ -162,24 +133,17 @@ class DonBG4(DonBGBase):
tex.draw_texture(self.name, 'overlay', frame=self.is_clear, fade=fade, x=(i*328)+self.move.attribute, y=self.overlay_move.attribute)
class DonBG5(DonBGBase):
def __init__(self, tex: TextureWrapper, index: int, screen_width: int, screen_height: int, player_num: int):
super().__init__(tex, index, screen_width, screen_height, player_num)
def __init__(self, tex: TextureWrapper, index: int, player_num: int):
super().__init__(tex, index, player_num)
self.bounce_up = tex.get_animation(4)
self.bounce_down = tex.get_animation(5)
self.adjust = tex.get_animation(8)
self.bounce_up.start()
self.bounce_down.start()
self.adjust.start()
def update(self, current_time_ms: float, is_clear: bool):
super().update(current_time_ms, is_clear)
self.bounce_up.update(current_time_ms)
self.bounce_down.update(current_time_ms)
self.adjust.update(current_time_ms)
if self.adjust.is_finished:
self.bounce_up.restart()
self.bounce_down.restart()
self.adjust.restart()
def draw(self, tex: TextureWrapper):
self._draw_textures(tex, 1.0)
@@ -193,15 +157,12 @@ class DonBG5(DonBGBase):
tex.draw_texture(self.name, 'overlay', frame=self.is_clear, fade=fade, x=(i*368)+(self.move.attribute * ((184/328)*2)), y=self.bounce_up.attribute - self.bounce_down.attribute - self.adjust.attribute)
class DonBG6(DonBGBase):
def __init__(self, tex: TextureWrapper, index: int, screen_width: int, screen_height: int, player_num: int):
super().__init__(tex, index, screen_width, screen_height, player_num)
def __init__(self, tex: TextureWrapper, index: int, player_num: int):
super().__init__(tex, index, player_num)
self.overlay_move = tex.get_animation(2)
self.overlay_move.start()
def update(self, current_time_ms: float, is_clear: bool):
super().update(current_time_ms, is_clear)
self.overlay_move.update(current_time_ms)
if self.overlay_move.is_finished:
self.overlay_move.restart()
def draw(self, tex: TextureWrapper):
self._draw_textures(tex, 1.0)
if self.is_clear:
@@ -218,98 +179,71 @@ class DonBG6(DonBGBase):
class BGNormal:
@staticmethod
def create(screen_width: int, screen_height: int, index: int):
map = [None, BGNormal1, BGNormal2, BGNormal3, BGNormal4, BGNormal5]
def create(tex: TextureWrapper, index: int):
map = [BGNormal1, BGNormal2, BGNormal3, BGNormal4, BGNormal5]
selected_obj = map[index]
return selected_obj(index, screen_width, screen_height)
return selected_obj(tex, index)
class BGNormalBase:
def __init__(self, index: int, screen_width: int, screen_height: int):
self.screen_width = screen_width
self.screen_height = screen_height
self.name = 'bg_nomal_a_' + str(index).zfill(2)
self.textures = (load_all_textures_from_zip(Path(f'Graphics/lumendata/enso_original/{self.name}.zip')))
def unload(self):
for texture_group in self.textures:
for texture in self.textures[texture_group]:
ray.unload_texture(texture)
def __init__(self, tex: TextureWrapper, index: int):
self.name = "bg_" + str(index)
tex.load_zip('background', f'bg_normal/{self.name}')
class BGNormal1(BGNormalBase):
def __init__(self, index: int, screen_width: int, screen_height: int):
super().__init__(index, screen_width, screen_height)
self.flicker = Animation.create_fade(16.67*4, initial_opacity=0.5, final_opacity=0.4, reverse_delay=0)
self.flicker.start()
def __init__(self, tex: TextureWrapper, index: int):
super().__init__(tex, index)
self.flicker = tex.get_animation(9)
def update(self, current_time_ms: float):
self.flicker.update(current_time_ms)
if self.flicker.is_finished:
self.flicker.restart()
def draw(self):
ray.draw_texture(self.textures[self.name][0], 0, 360, ray.WHITE)
ray.draw_texture(self.textures[self.name][1], 0, 360, ray.fade(ray.WHITE, self.flicker.attribute))
def draw(self, tex: TextureWrapper):
tex.draw_texture(self.name, 'background')
tex.draw_texture(self.name, 'overlay', fade=self.flicker.attribute)
class BGNormal2(BGNormalBase):
def __init__(self, index: int, screen_width: int, screen_height: int):
super().__init__(index, screen_width, screen_height)
self.flicker = Animation.create_fade(16.67*4, initial_opacity=0.5, final_opacity=0.4, reverse_delay=0)
self.flicker.start()
def __init__(self, tex: TextureWrapper, index: int):
super().__init__(tex, index)
self.flicker = tex.get_animation(9)
def update(self, current_time_ms: float):
self.flicker.update(current_time_ms)
if self.flicker.is_finished:
self.flicker.restart()
def draw(self):
ray.draw_texture(self.textures[self.name][0], 0, 360, ray.WHITE)
ray.draw_texture(self.textures[self.name][1], 0, 360, ray.fade(ray.WHITE, self.flicker.attribute))
def draw(self, tex: TextureWrapper):
tex.draw_texture(self.name, 'background')
tex.draw_texture(self.name, 'overlay', fade=self.flicker.attribute)
class BGNormal3(BGNormalBase):
def __init__(self, index: int, screen_width: int, screen_height: int):
super().__init__(index, screen_width, screen_height)
self.flicker = Animation.create_fade(16.67*10, initial_opacity=0.5, final_opacity=0.4, reverse_delay=0)
self.flicker.start()
def __init__(self, tex: TextureWrapper, index: int):
super().__init__(tex, index)
self.flicker = tex.get_animation(10)
def update(self, current_time_ms):
self.flicker.update(current_time_ms)
if self.flicker.is_finished:
self.flicker.restart()
def draw(self):
src = ray.Rectangle(0, 0, self.textures[self.name][0].width, self.textures[self.name][0].height)
dest = ray.Rectangle(0, 360, self.screen_width, self.textures[self.name][0].height)
ray.draw_texture_pro(self.textures[self.name][0], src, dest, ray.Vector2(0, 0), 0, ray.WHITE)
ray.draw_texture(self.textures[self.name][3], (self.screen_width//2) - (self.textures[self.name][3].width//2), 360, ray.WHITE)
ray.draw_texture(self.textures[self.name][6], 0, 360, ray.WHITE)
def draw(self, tex: TextureWrapper):
tex.draw_texture(self.name, 'background')
tex.draw_texture(self.name, 'center')
tex.draw_texture(self.name, 'overlay')
src = ray.Rectangle(0, 0, -self.textures[self.name][7].width, self.textures[self.name][7].height)
dest = ray.Rectangle((self.screen_width//2) - 170, 490, self.textures[self.name][7].width, self.textures[self.name][7].height)
ray.draw_texture_pro(self.textures[self.name][7], src, dest, ray.Vector2(0, 0), 0, ray.WHITE)
ray.draw_texture(self.textures[self.name][7], (self.screen_width//2) + 50, 490, ray.WHITE)
tex.draw_texture(self.name, 'lamps', index=0)
tex.draw_texture(self.name, 'lamps', index=1, mirror='horizontal')
tex.draw_texture(self.name, 'light_orange', index=0, fade=self.flicker.attribute)
tex.draw_texture(self.name, 'light_orange', index=1, fade=self.flicker.attribute)
tex.draw_texture(self.name, 'light_red', fade=self.flicker.attribute)
tex.draw_texture(self.name, 'light_green', fade=self.flicker.attribute)
tex.draw_texture(self.name, 'light_orange', index=2, fade=self.flicker.attribute)
tex.draw_texture(self.name, 'light_yellow', index=0, fade=self.flicker.attribute)
tex.draw_texture(self.name, 'light_yellow', index=1, fade=self.flicker.attribute)
#Orange
color = ray.fade(ray.WHITE, self.flicker.attribute)
ray.draw_texture(self.textures[self.name][1], (self.screen_width//2) + 180, 300, color)
ray.draw_texture(self.textures[self.name][1], (self.screen_width//2) - 380, 300, color)
#Red Green Orange
ray.draw_texture(self.textures[self.name][2], (self.screen_width//2) - 220, 350, color)
ray.draw_texture(self.textures[self.name][4], (self.screen_width//2) - 100, 350, color)
ray.draw_texture(self.textures[self.name][1], (self.screen_width//2) + 10, 350, color)
#Yellow
ray.draw_texture(self.textures[self.name][5], (self.screen_width//2) - 220, 500, color)
ray.draw_texture(self.textures[self.name][5], (self.screen_width//2) + 10, 500, color)
ray.draw_texture(self.textures[self.name][9], (self.screen_width//2) - 320, 520, ray.WHITE)
ray.draw_texture(self.textures[self.name][10], 100, 360, ray.WHITE)
ray.draw_texture(self.textures[self.name][11], self.screen_width - 100 - self.textures[self.name][11].width, 360, ray.WHITE)
tex.draw_texture(self.name, 'side_l')
tex.draw_texture(self.name, 'side_l_2')
tex.draw_texture(self.name, 'side_r')
class BGNormal4(BGNormalBase):
class Petal:
def __init__(self):
self.spawn_point = self.random_excluding_range()
duration = random.randint(1400, 2000)
self.move_y = Animation.create_move(duration, total_distance=360)
self.move_y.start()
self.move_x = Animation.create_move(duration, total_distance=random.randint(-300, 300))
self.move_y = Animation.create_move(duration, total_distance=360)
self.move_x.start()
self.move_y.start()
def random_excluding_range(self):
while True:
num = random.randint(0, 1280)
@@ -318,150 +252,116 @@ class BGNormal4(BGNormalBase):
def update(self, current_time_ms):
self.move_x.update(current_time_ms)
self.move_y.update(current_time_ms)
def draw(self, texture):
ray.draw_texture(texture, self.spawn_point + int(self.move_x.attribute), 360+int(self.move_y.attribute), ray.fade(ray.WHITE, 0.75))
def __init__(self, index: int, screen_width: int, screen_height: int):
super().__init__(index, screen_width, screen_height)
self.flicker = Animation.create_fade(16.67*3, initial_opacity=0.5, final_opacity=0.4, reverse_delay=0)
self.flicker.start()
self.turtle_move = Animation.create_move(3333*2, start_position=screen_width+112, total_distance=-(screen_width+(112*4)))
self.turtle_move.start()
textures = ((0, 100, 3), (100, 200, 4), (200, 300, 5), (300, 400, 6), (400, 500, 7), (500, 600, 8))
self.turtle_change = Animation.create_texture_change(600, textures=textures)
self.turtle_change.start()
def draw(self, name: str, tex: TextureWrapper):
tex.draw_texture(name, 'petal', x=self.spawn_point + self.move_x.attribute, y=360+self.move_y.attribute, fade=0.75)
def __init__(self, tex: TextureWrapper, index: int):
super().__init__(tex, index)
self.flicker = tex.get_animation(11)
self.turtle_move = tex.get_animation(12)
self.turtle_change = tex.get_animation(13)
self.petals = {self.Petal(), self.Petal(), self.Petal(), self.Petal(), self.Petal()}
def update(self, current_time_ms: float):
self.flicker.update(current_time_ms)
if self.flicker.is_finished:
self.flicker.restart()
self.turtle_move.update(current_time_ms)
if self.turtle_move.is_finished:
self.turtle_move.restart()
self.turtle_change.update(current_time_ms)
if self.turtle_change.is_finished:
self.turtle_change.restart()
for petal in self.petals:
petal.update(current_time_ms)
if petal.move_y.is_finished:
self.petals.remove(petal)
self.petals.add(self.Petal())
def draw(self):
ray.draw_texture(self.textures[self.name][0], 0, 360, ray.WHITE)
ray.draw_texture(self.textures[self.name][2], self.screen_width//2 - 20, 380, ray.WHITE)
ray.draw_texture(self.textures[self.name][self.turtle_change.attribute], int(self.turtle_move.attribute), 550, ray.WHITE)
def draw(self, tex: TextureWrapper):
tex.draw_texture(self.name, 'background')
tex.draw_texture(self.name, 'chara')
tex.draw_texture(self.name, 'turtle', frame=self.turtle_change.attribute, x=self.turtle_move.attribute)
ray.draw_texture(self.textures[self.name][9], 0, 360, ray.WHITE)
tex.draw_texture(self.name, 'overlay')
for petal in self.petals:
petal.draw(self.textures[self.name][10])
petal.draw(self.name, tex)
class BGNormal5(BGNormalBase):
def __init__(self, index: int, screen_width: int, screen_height: int):
super().__init__(index, screen_width, screen_height)
self.flicker = Animation.create_fade(16.67*10, initial_opacity=0.75, final_opacity=0.4, reverse_delay=0)
self.flicker.start()
def __init__(self, tex: TextureWrapper, index: int):
super().__init__(tex, index)
self.flicker = tex.get_animation(14)
def update(self, current_time_ms: float):
self.flicker.update(current_time_ms)
if self.flicker.is_finished:
self.flicker.restart()
def draw(self):
ray.draw_texture(self.textures[self.name][0], 0, 360, ray.WHITE)
def draw(self, tex: TextureWrapper):
tex.draw_texture(self.name, 'background')
ray.draw_texture(self.textures[self.name][13], -35, 340, ray.WHITE)
ray.draw_texture(self.textures[self.name][12], 103, 380, ray.WHITE)
ray.draw_texture(self.textures[self.name][11], 241, 400, ray.WHITE)
ray.draw_texture(self.textures[self.name][10], 380, 380, ray.WHITE)
ray.draw_texture(self.textures[self.name][9], 518, 340, ray.WHITE)
ray.draw_texture(self.textures[self.name][4], 657, 340, ray.WHITE)
ray.draw_texture(self.textures[self.name][5], 795, 380, ray.WHITE)
ray.draw_texture(self.textures[self.name][6], 934, 400, ray.WHITE)
ray.draw_texture(self.textures[self.name][7], 1072, 380, ray.WHITE)
ray.draw_texture(self.textures[self.name][8], 1211, 340, ray.WHITE)
tex.draw_texture(self.name, 'paper_lamp', frame=9, index=0)
tex.draw_texture(self.name, 'paper_lamp', frame=8, index=1)
tex.draw_texture(self.name, 'paper_lamp', frame=7, index=2)
tex.draw_texture(self.name, 'paper_lamp', frame=6, index=3)
tex.draw_texture(self.name, 'paper_lamp', frame=5, index=4)
tex.draw_texture(self.name, 'paper_lamp', frame=4, index=5)
tex.draw_texture(self.name, 'paper_lamp', frame=3, index=6)
tex.draw_texture(self.name, 'paper_lamp', frame=2, index=7)
tex.draw_texture(self.name, 'paper_lamp', frame=1, index=8)
tex.draw_texture(self.name, 'paper_lamp', frame=0, index=9)
color = ray.fade(ray.WHITE, self.flicker.attribute)
ray.draw_texture(self.textures[self.name][14], -35 - 10, 340 - 10, color)
ray.draw_texture(self.textures[self.name][14], 103 - 10, 380 - 10, color)
ray.draw_texture(self.textures[self.name][14], 241 - 10, 400 - 10, color)
ray.draw_texture(self.textures[self.name][14], 380 - 10, 380 - 10, color)
ray.draw_texture(self.textures[self.name][14], 518 - 10, 340 - 10, color)
ray.draw_texture(self.textures[self.name][14], 657 - 10, 340 - 10, color)
ray.draw_texture(self.textures[self.name][14], 795 - 10, 380 - 10, color)
ray.draw_texture(self.textures[self.name][14], 934 - 10, 400 - 10, color)
ray.draw_texture(self.textures[self.name][14], 1072 - 10, 380 - 10, color)
ray.draw_texture(self.textures[self.name][14], 1211 - 10, 340 - 10, color)
tex.draw_texture(self.name, 'light_overlay', index=0, fade=self.flicker.attribute)
tex.draw_texture(self.name, 'light_overlay', index=1, fade=self.flicker.attribute)
tex.draw_texture(self.name, 'light_overlay', index=2, fade=self.flicker.attribute)
tex.draw_texture(self.name, 'light_overlay', index=3, fade=self.flicker.attribute)
tex.draw_texture(self.name, 'light_overlay', index=4, fade=self.flicker.attribute)
tex.draw_texture(self.name, 'light_overlay', index=5, fade=self.flicker.attribute)
tex.draw_texture(self.name, 'light_overlay', index=6, fade=self.flicker.attribute)
tex.draw_texture(self.name, 'light_overlay', index=7, fade=self.flicker.attribute)
tex.draw_texture(self.name, 'light_overlay', index=8, fade=self.flicker.attribute)
tex.draw_texture(self.name, 'light_overlay', index=9, fade=self.flicker.attribute)
ray.draw_texture(self.textures[self.name][3], (self.screen_width//2) - (self.textures[self.name][3].width//2), 360+172, ray.fade(ray.WHITE, 0.75))
tex.draw_texture(self.name, 'overlay', fade=0.75)
ray.draw_texture(self.textures[self.name][1], 50, 600, ray.fade(ray.WHITE, 0.75))
ray.draw_texture(self.textures[self.name][1], self.screen_width-50 - self.textures[self.name][2].width, 600, ray.fade(ray.WHITE, 0.75))
ray.draw_texture(self.textures[self.name][2], self.screen_width-50 - self.textures[self.name][2].width, 600, ray.WHITE)
ray.draw_texture(self.textures[self.name][2], 50, 600, ray.WHITE)
tex.draw_texture(self.name, 'lamp_overlay', index=0, fade=0.75)
tex.draw_texture(self.name, 'lamp_overlay', index=1, fade=0.75)
tex.draw_texture(self.name, 'lamp', index=0)
tex.draw_texture(self.name, 'lamp', index=1)
class BGFever:
@staticmethod
def create(screen_width: int, screen_height: int, index: int):
map = [None, None, None, None, BGFever4]
def create(tex: TextureWrapper, index: int):
map = [None, None, None, BGFever4]
selected_obj = map[index]
return selected_obj(index, screen_width, screen_height)
return selected_obj(tex, index)
class BGFeverBase:
def __init__(self, index: int, screen_width: int, screen_height: int):
self.screen_width = screen_width
self.screen_height = screen_height
self.name = 'bg_fever_a_' + str(index).zfill(2)
self.textures = (load_all_textures_from_zip(Path(f'Graphics/lumendata/enso_original/{self.name}.zip')))
def __init__(self, tex: TextureWrapper, index: int):
self.name = 'bg_fever_' + str(index)
tex.load_zip('background', f'bg_fever/{self.name}')
self.transitioned = False
def unload(self):
for texture_group in self.textures:
for texture in self.textures[texture_group]:
ray.unload_texture(texture)
class BGFever4(BGFeverBase):
def __init__(self, index: int, screen_width: int, screen_height: int):
super().__init__(index, screen_width, screen_height)
self.vertical_move = Animation.create_move(1300, start_position=0, total_distance=50, reverse_delay=0)
self.vertical_move.start()
self.horizontal_move = Animation.create_move(5000, start_position=0, total_distance=self.textures[self.name][2].width)
self.horizontal_move.start()
self.bg_texture_move_down = None
self.bg_texture_move_up = None
def __init__(self, tex: TextureWrapper, index: int):
super().__init__(tex, index)
self.vertical_move = tex.get_animation(15)
self.horizontal_move = tex.get_animation(16)
self.bg_texture_move_down = tex.get_animation(17)
self.bg_texture_move_up = tex.get_animation(18)
def start(self):
self.bg_texture_move_down = Animation.create_move(516, total_distance=400, ease_in='cubic')
self.bg_texture_move_down.start()
self.bg_texture_move_up = Animation.create_move(200, total_distance=40, delay=self.bg_texture_move_down.duration, ease_out='quadratic')
self.bg_texture_move_up.start()
def update(self, current_time_ms: float):
if self.bg_texture_move_down is not None:
self.bg_texture_move_down.update(current_time_ms)
self.bg_texture_move_down.update(current_time_ms)
if self.bg_texture_move_up is not None:
self.bg_texture_move_up.update(current_time_ms)
if self.bg_texture_move_up.is_finished and not self.transitioned:
self.transitioned = True
self.vertical_move.restart()
self.horizontal_move.restart()
self.bg_texture_move_up.update(current_time_ms)
if self.bg_texture_move_up.is_finished and not self.transitioned:
self.transitioned = True
self.vertical_move.restart()
self.horizontal_move.restart()
if self.transitioned:
self.vertical_move.update(current_time_ms)
if self.vertical_move.is_finished:
self.vertical_move.restart()
self.horizontal_move.update(current_time_ms)
if self.horizontal_move.is_finished:
self.horizontal_move.restart()
def draw(self):
if self.bg_texture_move_down is None or self.bg_texture_move_up is None:
return
texture = self.textures[self.name][0]
y = int(self.bg_texture_move_down.attribute) - int(self.bg_texture_move_up.attribute)
for i in range(0, self.screen_width + texture.width, texture.width):
ray.draw_texture(texture, i, y, ray.WHITE)
ray.draw_texture(self.textures[self.name][1], 0, (720 + 50 - int(self.vertical_move.attribute)) - y, ray.WHITE)
ray.draw_texture(self.textures[self.name][2], -int(self.horizontal_move.attribute), y, ray.WHITE)
ray.draw_texture(self.textures[self.name][2], self.textures[self.name][2].width -int(self.horizontal_move.attribute), y, ray.WHITE)
def draw(self, tex: TextureWrapper):
y = self.bg_texture_move_down.attribute - self.bg_texture_move_up.attribute
for i in range(0, 1384, 104):
tex.draw_texture(self.name, 'background', x=i, y=y)
tex.draw_texture(self.name, 'overlay_1', y=-self.vertical_move.attribute - y)
tex.draw_texture(self.name, 'overlay_2', x=-self.horizontal_move.attribute, y=y)
tex.draw_texture(self.name, 'overlay_2', x=1256 - self.horizontal_move.attribute, y=y)
class Footer:
def __init__(self, tex: TextureWrapper, index: int):

26
libs/song_hash.py
View File

@@ -31,18 +31,24 @@ def read_tjap3_score(input_file: Path):
int(score_ini['HiScore.Drums']['HiScore3']),
int(score_ini['HiScore.Drums']['HiScore4']),
int(score_ini['HiScore.Drums']['HiScore5'])]
clears = [int(score_ini['HiScore.Drums']['Clear0']),
int(score_ini['HiScore.Drums']['Clear1']),
int(score_ini['HiScore.Drums']['Clear2']),
int(score_ini['HiScore.Drums']['Clear3']),
int(score_ini['HiScore.Drums']['Clear4'])]
clears = [int(score_ini['HiScore.Drums'].get('Clear0', 0)),
int(score_ini['HiScore.Drums'].get('Clear1', 0)),
int(score_ini['HiScore.Drums'].get('Clear2', 0)),
int(score_ini['HiScore.Drums'].get('Clear3', 0)),
int(score_ini['HiScore.Drums'].get('Clear4', 0))]
if score_ini['HiScore.Drums']['PerfectRange'] != 25:
return [0],[0]
return [0],[0], None
if score_ini['HiScore.Drums']['GoodRange'] != 75:
return [0],[0]
return [0],[0], None
if score_ini['HiScore.Drums']['PoorRange'] != 108:
return [0],[0]
return scores, clears
return [0],[0], None
if score_ini['HiScore.Drums']['Perfect'] != 0:
good = score_ini['HiScore.Drums'].get('Perfect', 0)
ok = score_ini['HiScore.Drums'].get('Great', 0)
bad = score_ini['HiScore.Drums'].get('Miss', 0)
return scores, clears, [good, ok, bad]
else:
return scores, clears, None
def build_song_hashes(output_dir=Path("cache")):
if not output_dir.exists():
@@ -149,7 +155,7 @@ def build_song_hashes(output_dir=Path("cache")):
score_ini_path = tja_path.with_suffix('.tja.score.ini')
if score_ini_path.exists():
imported_scores, imported_clears = read_tjap3_score(score_ini_path)
imported_scores, imported_clears, _ = read_tjap3_score(score_ini_path)
conn = sqlite3.connect(db_path)
cursor = conn.cursor()
for i in range(len(imported_scores)):

76
libs/texture.py
View File

@@ -24,11 +24,11 @@ class Texture:
self.height = self.texture.height
self.is_frames = isinstance(self.texture, list)
self.x = 0
self.y = 0
self.x2 = self.width
self.y2 = self.height
self.controllable = False
self.x: list[int] = [0]
self.y: list[int] = [0]
self.x2: list[int] = [self.width]
self.y2: list[int] = [self.height]
self.controllable: list[bool] = [False]
class TextureWrapper:
def __init__(self):
@@ -50,20 +50,35 @@ class TextureWrapper:
if index not in self.animations:
raise Exception(f"Unable to find id {index} in loaded animations")
if is_copy:
return copy.deepcopy(self.animations[index])
new_anim = copy.deepcopy(self.animations[index])
if self.animations[index].loop:
new_anim.start()
return new_anim
if self.animations[index].loop:
self.animations[index].start()
return self.animations[index]
def update_attr(self, subset: str, texture: str, attr: str, value: float | int):
tex_object = self.textures[subset][texture]
if hasattr(tex_object, attr):
setattr(tex_object, attr, tex_object.init_vals[attr] + value)
def _read_tex_obj_data(self, tex_mapping: dict, tex_object: Texture):
tex_object.x = tex_mapping.get("x", 0)
tex_object.y = tex_mapping.get("y", 0)
tex_object.x2 = tex_mapping.get("x2", tex_object.width)
tex_object.y2 = tex_mapping.get("y2", tex_object.height)
tex_object.controllable = tex_mapping.get("controllable", False)
def _read_tex_obj_data(self, tex_mapping: dict | list, tex_object: Texture):
if isinstance(tex_mapping, list):
for i in range(len(tex_mapping)):
if i == 0:
tex_object.x[i] = tex_mapping[i].get("x", 0)
tex_object.y[i] = tex_mapping[i].get("y", 0)
tex_object.x2[i] = tex_mapping[i].get("x2", tex_object.width)
tex_object.y2[i] = tex_mapping[i].get("y2", tex_object.height)
tex_object.controllable[i] = tex_mapping[i].get("controllable", False)
else:
tex_object.x.append(tex_mapping[i].get("x", 0))
tex_object.y.append(tex_mapping[i].get("y", 0))
tex_object.x2.append(tex_mapping[i].get("x2", tex_object.width))
tex_object.y2.append(tex_mapping[i].get("y2", tex_object.height))
tex_object.controllable.append(tex_mapping[i].get("controllable", False))
else:
tex_object.x = [tex_mapping.get("x", 0)]
tex_object.y = [tex_mapping.get("y", 0)]
tex_object.x2 = [tex_mapping.get("x2", tex_object.width)]
tex_object.y2 = [tex_mapping.get("y2", tex_object.height)]
tex_object.controllable = [tex_mapping.get("controllable", False)]
def load_animations(self, screen_name: str):
screen_path = self.graphics_path / screen_name
@@ -125,26 +140,27 @@ class TextureWrapper:
continue
self.load_zip(screen_name, zip.name)
def control(self, tex_object: Texture):
def control(self, tex_object: Texture, index: int = 0):
distance = 1
if ray.is_key_down(ray.KeyboardKey.KEY_LEFT_SHIFT):
distance = 10
if ray.is_key_pressed(ray.KeyboardKey.KEY_LEFT):
tex_object.x -= distance
print(f"{tex_object.name}: {tex_object.x}, {tex_object.y}")
tex_object.x[index] -= distance
print(f"{tex_object.name}: {tex_object.x[index]}, {tex_object.y[index]}")
if ray.is_key_pressed(ray.KeyboardKey.KEY_RIGHT):
tex_object.x += distance
print(f"{tex_object.name}: {tex_object.x}, {tex_object.y}")
tex_object.x[index] += distance
print(f"{tex_object.name}: {tex_object.x[index]}, {tex_object.y[index]}")
if ray.is_key_pressed(ray.KeyboardKey.KEY_UP):
tex_object.y -= distance
print(f"{tex_object.name}: {tex_object.x}, {tex_object.y}")
tex_object.y[index] -= distance
print(f"{tex_object.name}: {tex_object.x[index]}, {tex_object.y[index]}")
if ray.is_key_pressed(ray.KeyboardKey.KEY_DOWN):
tex_object.y += distance
print(f"{tex_object.name}: {tex_object.x}, {tex_object.y}")
tex_object.y[index] += distance
print(f"{tex_object.name}: {tex_object.x[index]}, {tex_object.y[index]}")
def draw_texture(self, subset: str, texture: str, color: ray.Color=ray.WHITE, frame: int = 0, scale: float = 1.0, center: bool = False,
mirror: str = '', x: float = 0, y: float = 0, x2: float = 0, y2: float = 0,
origin: ray.Vector2 = ray.Vector2(0,0), rotation: float = 0, fade: float = 1.1) -> None:
origin: ray.Vector2 = ray.Vector2(0,0), rotation: float = 0, fade: float = 1.1,
index: int = 0) -> None:
mirror_x = -1 if mirror == 'horizontal' else 1
mirror_y = -1 if mirror == 'vertical' else 1
if fade != 1.1:
@@ -154,9 +170,9 @@ class TextureWrapper:
tex_object = self.textures[subset][texture]
source_rect = ray.Rectangle(0, 0, tex_object.width * mirror_x, tex_object.height * mirror_y)
if center:
dest_rect = ray.Rectangle(tex_object.x + (tex_object.width//2) - ((tex_object.width * scale)//2) + x, tex_object.y + (tex_object.height//2) - ((tex_object.height * scale)//2) + y, tex_object.x2*scale + x2, tex_object.y2*scale + y2)
dest_rect = ray.Rectangle(tex_object.x[index] + (tex_object.width//2) - ((tex_object.width * scale)//2) + x, tex_object.y[index] + (tex_object.height//2) - ((tex_object.height * scale)//2) + y, tex_object.x2[index]*scale + x2, tex_object.y2[index]*scale + y2)
else:
dest_rect = ray.Rectangle(tex_object.x + x, tex_object.y + y, tex_object.x2*scale + x2, tex_object.y2*scale + y2)
dest_rect = ray.Rectangle(tex_object.x[index] + x, tex_object.y[index] + y, tex_object.x2[index]*scale + x2, tex_object.y2[index]*scale + y2)
if tex_object.is_frames:
if not isinstance(tex_object.texture, list):
raise Exception("Texture was marked as multiframe but is only 1 texture")
@@ -167,7 +183,7 @@ class TextureWrapper:
if isinstance(tex_object.texture, list):
raise Exception("Texture is multiframe but was called as 1 texture")
ray.draw_texture_pro(tex_object.texture, source_rect, dest_rect, origin, rotation, final_color)
if tex_object.controllable:
if tex_object.controllable[index]:
self.control(tex_object)
tex = TextureWrapper()