batframework 1.0.9a10__py3-none-any.whl → 1.1.0__py3-none-any.whl

batFramework/animatedSprite.py

@@ -1,59 +1,117 @@
 import batFramework as bf
 import pygame
-from typing import List, Dict, Tuple, Union, Optional, Self, Callable, Any
-from .animation import Animation
-
-class AnimatedSprite(bf.Drawable):
-    def __init__(self,*args,**kwargs) -> None:
-        super().__init__(None, no_surface=True,*args,**kwargs)
-        self.animations : dict[str,Animation] = {}
-        self.counter = 0 # int counter
-        self._fcounter = 0.0 # counter
-        self.current_animation : str = None
-        self.end_callback : Callable[[],Any] = None
-        self._flipX : bool = False 
-
-    @property
-    def flipX(self)->bool:
-        return self._flipX
-    
-    @flipX.setter
-    def flipX(self,value:bool):
-        self._flipX = value
-
-    def set_end_callback(self,callback : Callable[[],Any]):
-        self.end_callback = callback 
-
-    def add_animation(self,name:str,animation:Animation)->Self:
-        self.animations[name] = animation
-        if self.rect.size == (0,0):
-            self.rect.size = animation.frames[0].get_size()
-        return self
-    
-    def set_animation(self,name:str,reset_counter:bool=True):
-        if name not in self.animations :
-            raise ValueError
-        self.current_animation = name
-        if reset_counter:
-            self._fcounter = 0
-
-    def get_current_frame(self)->int|None:
-        if not self.current_animation:
-            return None
-        return  self.animations[self.current_animation].counter_to_frame(self._fcounter)        
-
-    def update(self, dt):
-        super().update(dt)        
-        if not self.current_animation:
+
+
+
+def search_index(target, lst):
+    cumulative_sum = 0
+    for index, value in enumerate(lst):
+        cumulative_sum += value
+        if cumulative_sum >= target:
+            return index
+    return -1
+
+
+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
+        )
+
+        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_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 = 0
+        self.animStates: dict[str, AnimState] = {}
+        self.current_animState :str = ""
+        self.flipX = False
+        self._locked = False
+
+    def set_counter(self,value:float):
+        self.float_counter = value
+        
+
+    def lock_animState(self):
+        self._locked = True
+
+    def unlock_animState(self):
+        self._locked = False
+
+    def set_flipX(self, value):
+        self.flipX = value
+
+    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._fcounter += dt
-        self.counter = int(self._fcounter)
-        if self.counter >= self.animations[self.current_animation].numFrames:
-            if self.end_callback:
-                self.end_callback()
-            
-
-    def draw(self, camera):
-        self.surface.blit(self.animations[self.current_animation].get_frame(self.counter,self.flipX),(0,0))
-        super().draw(camera)
-        
+        self.animStates[name] = AnimState(file, *size, frame_length_list)
+        if len(self.animStates) == 1 : self.set_animState(name)
+
+    def set_animState(self, state:str, reset_counter=True, lock=False):
+        if state not in self.animStates or self._locked:
+            return False
+        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 get_state(self):
+        return self.animStates.get(self.current_animState,None)
+
+    def get_frame_index(self):
+        return self.animStates[self.current_animState].get_frame_index(
+            self.float_counter
+        )
+
+    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)
+
+    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_state().get_frame(self.float_counter, self.flipX),
+            camera.transpose(self.rect),
+        )
+        return True

batFramework/audioManager.py

@@ -1,53 +1,43 @@
 import batFramework as bf
 import pygame
 
-
+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
-        pygame.mixer.music.set_endevent(bf.const.MUSIC_END_EVENT)
-
-    def free_sounds(self, force: bool = False):
+    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=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
 
     def set_music_volume(self, volume: float):
         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
+        pygame.mixer_music.set_volume(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 persistent==True the sound won't be unloaded when sounds are freed (unless force is used)
-        """
         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),
@@ -55,77 +45,41 @@ class AudioManager(metaclass=bf.Singleton):
         }
         return self.sounds[name]["sound"]
 
-    def load_sounds(self, sound_data: tuple[str, str, bool]) -> None:
-        for data in sound_data:
-            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:tuple[str, str]):
-        for data in music_data:
-            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:
-            pygame.mixer.music.load(self.musics[name])
-            pygame.mixer.music.play(loop, fade_ms=fade)
+        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:
-            print(f"Music '{name}' not loaded in AudioManager.")
-            return False
+        else:
+            print(f"Music '{name}' not found in AudioManager.")
 
     def stop_music(self):
         if not self.current_music:
             return
-        pygame.mixer.music.stop()
+        pygame.mixer_music.stop()
 
     def fadeout_music(self, fade_ms: int):
         if not self.current_music:
             return
-        pygame.mixer.music.fadeout(fade_ms)
+        pygame.mixer_music.fadeout(fade_ms)
 
     def pause_music(self):
         if not self.current_music:
             return
-        pygame.mixer.music.pause()
+        pygame.mixer_music.pause()
 
     def resume_music(self):
         if not self.current_music:
             return
-        pygame.mixer.music.unpause()
-
-    def get_current_music(self) -> str | None:
-        return self.current_music
+        pygame.mixer_music.unpause()