batframework 1.0.8a7__py3-none-any.whl → 1.0.8a8__py3-none-any.whl

batFramework/animatedSprite.py

@@ -1,9 +1,9 @@
 import batFramework as bf
 import pygame
-from typing import List, Dict, Tuple, Union, Optional, Self
 
 
-def search_index(target: int, lst: List[int]) -> int:
+
+def search_index(target, lst):
     cumulative_sum = 0
     for index, value in enumerate(lst):
         cumulative_sum += value
@@ -12,165 +12,106 @@ def search_index(target: int, lst: List[int]) -> int:
     return -1
 
 
-class Animation:
-    def __init__(
-        self,
-        name: str
-    ) -> None:
-        self.name = name
-        self.frames: list[pygame.Surface] = []
-        self.frames_flipX : list[pygame.Surface] = []
-        self.duration_list = []
-        self.duration_list_length = 1
-
-    def from_surface(self,surface:pygame.Surface,size : Tuple[int,int])->Self:
-        self.frames         : List[pygame.Surface] = list(bf.utils.split_surface(surface, size).values())
-        self.frames_flipX   : List[pygame.Surface] = list(bf.utils.split_surface(surface, size,func=lambda s : pygame.transform.flip(s,True,False)).values())
-        return self
-
-    def __repr__(self):
-        return f"Animation({self.name})"
-
-    def counter_to_frame(self, counter: Union[float, int]) -> int:
-        if not self.frames : 
-            raise ValueError("Animation has no frames")
-        return search_index(
-            int(counter % self.duration_list_length), self.duration_list
+class AnimState:
+    def __init__(self, file, width, height, frame_length_list:list|int) -> None:
+        self.frames: list[pygame.Surface] = bf.utils.img_slice(file, width, height)
+        self.frames_flipX: list[pygame.Surface] = bf.utils.img_slice(
+            file, width, height, True
         )
 
-    def get_frame(self, counter: Union[float, int], flip: bool) -> pygame.Surface:
-        i = self.counter_to_frame(counter)
+        self.frame_length_list = []
+        self.ffl_length = 0
+        self.set_frame_length_list(frame_length_list)
+
+    def get_frame_index(self, counter:float|int):
+        return search_index(int(counter % self.ffl_length), self.frame_length_list)
+
+    def get_frame(self, counter, flip):
+        i = self.get_frame_index(counter)
         return self.frames_flipX[i] if flip else self.frames[i]
 
-    def set_duration_list(self, duration_list: Union[List[int], int]) -> Self:
-        if isinstance(duration_list, int):
-            duration_list = [duration_list] * len(self.frames)
-        if len(duration_list) != len(self.frames):
-            raise ValueError("duration_list should have values for all frames")
-        self.duration_list = duration_list
-        self.duration_list_length = sum(self.duration_list)
-        return self
-
-class AnimatedSprite(bf.Entity):
-    def __init__(self, size: Optional[Tuple[int, int]] = None) -> None:
+    def set_frame_length_list(self,frame_length_list:list[int]|int):
+        if isinstance(frame_length_list,int):
+            frame_length_list = [frame_length_list] * len(self.frames)
+        if len(frame_length_list) != len(self.frames) : 
+            raise ValueError("frame_length_list should have values for all frames")
+        self.frame_length_list = frame_length_list
+        self.ffl_length = sum(self.frame_length_list)
+        
+
+class AnimatedSprite(bf.DynamicEntity):
+    def __init__(self, size=None) -> None:
         super().__init__(size, no_surface=True)
-        self.float_counter: float = 0
-        self.animations: Dict[str, Animation] = {}
-        self.current_state: Optional[Animation] = None
-        self.flipX: bool = False
-        self._locked: bool = False
-        self._paused: bool = False
-        self.animation_end_callback = None
-        self.transition_end_animation = None
-
-    def set_animation_end_callback(self,callback)->Self:
-        self.animation_end_callback = callback
-        return self
-
-    @property
-    def paused(self) -> bool:
-        return self._paused
-
-    @paused.setter
-    def paused(self, value: bool) -> None:
-        self._paused = value
-
-    def toggle_pause(self) -> None:
-        self.paused = not self.paused
-
-    def set_counter(self, value: float) -> None:
-        self.float_counter = value
+        self.float_counter = 0
+        self.animStates: dict[str, AnimState] = {}
+        self.current_animState :str = ""
+        self.flipX = False
+        self._locked = False
 
-    def set_frame(self, frame_index: int) -> None:
-        if not self.current_state:
-            return
-        self.set_counter(sum(self.current_state.duration_list[:frame_index]))
+    def set_counter(self,value:float):
+        self.float_counter = value
+        
 
-    def lock(self) -> None:
+    def lock_animState(self):
         self._locked = True
 
-    def unlock(self) -> None:
+    def unlock_animState(self):
         self._locked = False
 
-    def set_flipX(self, value: bool) -> None:
+    def set_flipX(self, value):
         self.flipX = value
 
-    def remove_animation(self, name: str) -> bool:
-        if name not in self.animations:
-            return False
-        self.animations.pop(name)
-        if self.current_state and self.current_state.name == name:
-            self.current_state = (
-                list(self.animations.values())[0] if self.animations else None
-            )
-        return True
+    def remove_animState(self, name:str):
+        if not name in self.animStates :return
+        self.animStates.pop(name) 
+        if self.current_animState == name : self.current_animState = list(self.animStates.keys())[0] if self.animStates else "" 
+
+    def add_animState(
+        self, name: str, file: str, size: tuple[int, int], frame_length_list: list[int]
+    ):
+        if name in self.animStates:
+            return
+        self.animStates[name] = AnimState(file, *size, frame_length_list)
+        if len(self.animStates) == 1 : self.set_animState(name)
 
-    def add_animation(
-        self,
-        animation:Animation
-    ) -> bool:
-        if animation.name in self.animations:
+    def set_animState(self, state:str, reset_counter=True, lock=False):
+        if state not in self.animStates or self._locked:
             return False
-        self.animations[animation.name] = animation
+        self.current_animState = state
+        self.rect = (
+            self.animStates[self.current_animState]
+            .frames[0]
+            .get_frect(center=self.rect.center)
+        )
+        if reset_counter or self.float_counter > sum(
+            self.get_state().frame_length_list
+        ):
+            self.float_counter = 0
+        if lock:
+            self.lock_animState()
         return True
 
-    def set_animation(
-        self, state: str, reset_counter: bool = True, lock: bool = False
-    ) -> bool:
-        if state not in self.animations or self._locked:
-            return False
-        
-        animation = self.animations[state]
-        self.current_state = animation
+    def get_state(self):
+        return self.animStates.get(self.current_animState,None)
 
-        if self.current_state.frames:
-            self.rect = self.current_state.frames[0].get_frect(center=self.rect.center)
+    def get_frame_index(self):
+        return self.animStates[self.current_animState].get_frame_index(
+            self.float_counter
+        )
 
-        if reset_counter or (self.float_counter > animation.duration_list_length):
+    def update(self, dt: float):
+        if not self.animStates : return
+        self.float_counter += 60 * dt
+        if self.float_counter > self.get_state().ffl_length:
             self.float_counter = 0
+        self.do_update(dt)
 
-        if lock:
-            self.lock()
-        
-        if self.transition_end_animation is not None:
-            self.transition_end_animation = None
-        return True
-    
-    def transition_to_animation(self,transition:str,animation:str)->Self:
-        self.set_animation(transition)
-        self.transition_end_animation = animation
-        return self
-    
-    def get_current_animation(self) -> Optional[Animation]:
-        return self.current_state
-
-    def update(self, dt: float) -> None:
-        s = self.get_current_animation()
-        if  self.animations and s is not None:
-            if not self.paused:
-                self.float_counter += 60 * dt
-                if self.float_counter > s.duration_list_length:
-                    if self.transition_end_animation is not None:
-                        # print(f"{self.transition_end_animation=}, {self.get_current_animation()=}")
-                        self.set_animation(self.transition_end_animation)
-                    if self.animation_end_callback is not None:
-                        self.animation_end_callback()
-                    self.float_counter = 0
-        super().update(dt)
-
-
-    def get_current_frame(self)->pygame.Surface:
-        return self.current_state.get_frame(self.float_counter, self.flipX)
-
-    def draw(self, camera: bf.Camera) -> None:
-        if (
-            not self.visible
-            or not camera.rect.colliderect(self.rect)
-            or not self.current_state
-        ):
-            return
+    def draw(self, camera: bf.Camera) -> bool:
+        if not self.visible or not camera.intersects(self.rect) or not self.animStates:
+            return False
+        # pygame.draw.rect(camera.surface,"purple",camera.transpose(self.rect).move(2,2))
         camera.surface.blit(
-            self.get_current_frame(),
-            camera.world_to_screen(self.rect),
+            self.get_state().get_frame(self.float_counter, self.flipX),
+            camera.transpose(self.rect),
         )
-        return 
+        return True

batFramework/audioManager.py

@@ -5,25 +5,24 @@ pygame.mixer.init()
 
 
 class AudioManager(metaclass=bf.Singleton):
-    def __init__(self) -> None:
-        self.sounds: dict = {}
-        self.musics: dict = {}
-        self.current_music: str | None = None
-        self.music_volume: float = 1
-        self.sound_volume: float = 1
+    def __init__(self):
+        self.sounds: dict[str : dict[str, pygame.mixer.Sound, bool]] = {}
+        self.musics: dict[str:str] = {}
+        self.current_music = None
+        self.music_volume = 1
+        self.sound_volume = 1
         pygame.mixer_music.set_endevent(bf.const.MUSIC_END_EVENT)
 
-    def free_sounds(self, force: bool = False):
+    def free_sounds(self, force=False):
         if force:
             self.sounds = {}
             return
-        self.sounds: dict = {
-            key: value for key, value in self.sounds.items() if value["persistent"]
-        }
+        to_remove = []
+        for name, data in self.sounds.items():
+            if not data["persistent"]:
+                to_remove.append(name)
 
-    def free_music(self):
-        if self.current_music:
-            pygame.mixer.music.unload(self.current_music)
+        _ = [self.sounds.pop(i) for i in to_remove]
 
     def set_sound_volume(self, volume: float):
         self.sound_volume = volume
@@ -32,19 +31,13 @@ class AudioManager(metaclass=bf.Singleton):
         self.music_volume = volume
         pygame.mixer_music.set_volume(volume)
 
-    def get_music_volume(self) -> float:
-        return self.music_volume
-
-    def get_sound_volume(self) -> float:
-        return self.sound_volume
-
-    def has_sound(self, name: str):
+    def has_sound(self, name):
         return name in self.sounds
 
     def load_sound(self, name, path, persistent=False) -> pygame.mixer.Sound:
         if name in self.sounds:
             return self.sounds[name]["sound"]
-        path = bf.ResourceManager().get_path(path)
+        path = bf.utils.get_path(path)
         self.sounds[name] = {
             "path": path,
             "sound": pygame.mixer.Sound(path),
@@ -52,57 +45,24 @@ class AudioManager(metaclass=bf.Singleton):
         }
         return self.sounds[name]["sound"]
 
-    def load_sounds(self, sound_data_list: list[tuple[str, str, bool]]) -> None:
-        for data in sound_data_list:
-            self.load_sound(*data)
-        return
-
-    def play_sound(self, name, volume=1) -> bool:
-        """
-        Play the sound file with the given name.
-        returns True if the sound was played
-
-        """
-        try:
-            self.sounds[name]["sound"].set_volume(volume * self.sound_volume)
-            self.sounds[name]["sound"].play()
-            return True
-        except KeyError:
-            print(f"Sound '{name}' not loaded in AudioManager.")
-            return False
-
-    def stop_sound(self, name) -> bool:
-        try:
+    def play_sound(self, name, volume=1):
+        self.sounds[name]["sound"].set_volume(volume * self.sound_volume)
+        self.sounds[name]["sound"].play()
+
+    def stop_sound(self, name):
+        if name in self.sounds:
             self.sounds[name]["sound"].stop()
-            return True
-        except KeyError:
-            return False
-            print(f"Sound '{name}' not loaded in AudioManager.")
 
     def load_music(self, name, path):
-        self.musics[name] = bf.ResourceManager().get_path(path)
-        return
-
-    def load_musics(self, music_data_list: list[tuple[str, str]]):
-        for data in music_data_list:
-            self.load_music(*data)
-        return
-
-    def play_music(self, name, loop=0, fade=500) -> bool:
-        """
-        Play the sound file with the given 'name'.
-        Fades with the given 'fade' time in ms.
-        Music will loop 'loop' times (indefinitely if -1).
-        returns True if the sound was played
-        """
-        try:
+        self.musics[name] = bf.utils.get_path(path)
+
+    def play_music(self, name, loop=0, fade=500):
+        if name in self.musics:
             pygame.mixer_music.load(self.musics[name])
             pygame.mixer_music.play(loop, fade_ms=fade)
             self.current_music = name
-            return True
-        except KeyError:
-            return False
-            # print(f"Music '{name}' not loaded in AudioManager.")
+        else:
+            print(f"Music '{name}' not found in AudioManager.")
 
     def stop_music(self):
         if not self.current_music:
@@ -123,6 +83,3 @@ class AudioManager(metaclass=bf.Singleton):
         if not self.current_music:
             return
         pygame.mixer_music.unpause()
-
-    def get_current_music(self) -> str | None:
-        return self.current_music