batframework 1.0.9a11__py3-none-any.whl → 1.0.9a13__py3-none-any.whl

batFramework/actionContainer.py

@@ -1,82 +1,105 @@
-import batFramework as bf
-import pygame
-
-
-class ActionContainer:
-    def __init__(self, *actions: list[bf.Action]) -> None:
-        self._actions: dict[str, bf.Action] = {}
-        if actions:
-            self.add_actions(*actions)
-
-    def __iter__(self):
-        return iter(self._actions.values())
-
-    def clear(self):
-        self._actions = {}
-
-    def add_actions(self, *actions: bf.Action):
-        for action in actions:
-            self._actions[action.name] = action
-
-    def get(self, name: str) -> bf.Action:
-        return self._actions.get(name)
-
-    def has_action(self, name: str):
-        return name in self._actions
-
-    def get_all(self) -> list[bf.Action]:
-        return self._actions
-
-    def is_active(self, *names: str) -> bool:
-        return all(
-            self._actions.get(name).active if name in self._actions else False
-            for name in names
-        )
-
-    def process_event(self, event):
-        if event.consumed:
-            return
-        for action in self._actions.values():
-            action.process_event(event)
-            if event.consumed == True:
-                break
-
-    def reset(self):
-        for action in self._actions.values():
-            action.reset()
-
-    def hard_reset(self):
-        for action in self._actions.values():
-            action.hard_reset()
-
-
-class DirectionalKeyControls(ActionContainer):
-    def __init__(self):
-        super().__init__(
-            bf.Action("up").add_key_control(pygame.K_UP).set_holding(),
-            bf.Action("down").add_key_control(pygame.K_DOWN).set_holding(),
-            bf.Action("left").add_key_control(pygame.K_LEFT).set_holding(),
-            bf.Action("right").add_key_control(pygame.K_RIGHT).set_holding(),
-        )
-
-
-class WASDControls(ActionContainer):
-    def __init__(self):
-        super().__init__(
-            bf.Action("up").add_key_control(pygame.K_w).set_holding(),
-            bf.Action("down").add_key_control(pygame.K_s).set_holding(),
-            bf.Action("left").add_key_control(pygame.K_a).set_holding(),
-            bf.Action("right").add_key_control(pygame.K_d).set_holding(),
-        )
-
-
-class HybridControls(ActionContainer):
-    def __init__(self):
-        super().__init__(
-            bf.Action("up").add_key_control(pygame.K_UP, pygame.K_w).set_holding(),
-            bf.Action("down").add_key_control(pygame.K_DOWN, pygame.K_s).set_holding(),
-            bf.Action("left").add_key_control(pygame.K_LEFT, pygame.K_a).set_holding(),
-            bf.Action("right")
-            .add_key_control(pygame.K_RIGHT, pygame.K_r)
-            .set_holding(),
-        )
+import batFramework as bf
+import pygame
+
+
+class ActionContainer:
+    def __init__(self, *actions: list[bf.Action]) -> None:
+        self._actions: dict[str, bf.Action] = {}
+        if actions:
+            self.add_actions(*actions)
+
+    def __iter__(self):
+        return iter(self._actions.values())
+
+    def __getitem__(self, key):
+        return self._actions[key]
+
+    def __setitem__(self, key, value):
+        self._actions[key] = value
+
+    def __delitem__(self, key):
+        del self._actions[key]
+
+    def __contains__(self, key):
+        return key in self._actions
+
+    def __repr__(self):
+        return repr(self._actions)
+
+
+
+    def clear(self):
+        self._actions = {}
+
+    def add_actions(self, *actions: bf.Action):
+        for action in actions:
+            self._actions[action.name] = action
+
+    def get(self, name: str) -> bf.Action:
+        return self._actions.get(name)
+
+    def has_action(self, name: str):
+        return name in self._actions
+
+    def get_all(self) -> list[bf.Action]:
+        return self._actions
+
+    def is_active(self, *names: str) -> bool:
+        return all(
+            self._actions.get(name).active if name in self._actions else False
+            for name in names
+        )
+
+    def is_any_active(self,*names:str) -> bool:
+        return any(
+            self._actions.get(name).active if name in self._actions else False
+            for name in names
+        )
+
+    def process_event(self, event):
+        if event.consumed:
+            return
+        for action in self._actions.values():
+            action.process_event(event)
+            if event.consumed == True:
+                break
+
+    def reset(self):
+        for action in self._actions.values():
+            action.reset()
+
+    def hard_reset(self):
+        for action in self._actions.values():
+            action.hard_reset()
+
+
+class DirectionalKeyControls(ActionContainer):
+    def __init__(self):
+        super().__init__(
+            bf.Action("up").add_key_control(pygame.K_UP).set_holding(),
+            bf.Action("down").add_key_control(pygame.K_DOWN).set_holding(),
+            bf.Action("left").add_key_control(pygame.K_LEFT).set_holding(),
+            bf.Action("right").add_key_control(pygame.K_RIGHT).set_holding(),
+        )
+
+
+class WASDControls(ActionContainer):
+    def __init__(self):
+        super().__init__(
+            bf.Action("up").add_key_control(pygame.K_w).set_holding(),
+            bf.Action("down").add_key_control(pygame.K_s).set_holding(),
+            bf.Action("left").add_key_control(pygame.K_a).set_holding(),
+            bf.Action("right").add_key_control(pygame.K_d).set_holding(),
+        )
+
+
+class HybridControls(ActionContainer):
+    def __init__(self):
+        super().__init__(
+            bf.Action("up").add_key_control(pygame.K_UP, pygame.K_w).set_holding(),
+            bf.Action("down").add_key_control(pygame.K_DOWN, pygame.K_s).set_holding(),
+            bf.Action("left").add_key_control(pygame.K_LEFT, pygame.K_a).set_holding(),
+            bf.Action("right")
+            .add_key_control(pygame.K_RIGHT, pygame.K_r)
+            .set_holding(),
+        )

batFramework/animatedSprite.py

@@ -1,59 +1,81 @@
-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:
-            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)
+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__((0,0),*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
+        self.animation_loop : int = -1
+        self.queued_animation : str = None
+
+    @property
+    def flipX(self)->bool:
+        return self._flipX
+    
+    @flipX.setter
+    def flipX(self,value:bool):
+        self._flipX = value
+
+    def set_animation_end_callback(self,callback : Callable[[],Any]):
+        self.end_callback = callback 
+
+    def add_animation(self,animation:Animation)->Self:
+        self.animations[animation.name] = animation
+        if self.rect.size == (0,0):
+            self.rect.size = animation.frames[0].get_size()
+            self.surface = animation.frames[0].copy()
+        return self
+    
+    def set_animation(self,name:str,reset_counter:bool=True,loop:int=-1,queued_animation:str=None):
+        """
+        Sets the current animation,
+        if animation with given name hasn't been added, nothing happens
+        """
+        if name not in self.animations :
+            return
+        self.current_animation = name
+        if reset_counter:
+            self._fcounter = 0
+            self.counter = 0
+        self.animation_loop = loop
+        if loop != -1:
+            self.queued_animation = queued_animation
+        else:
+            self.queued_animation = None
+
+    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:
+            return
+        self._fcounter += dt * 60 
+        self.counter = int(self._fcounter)
+        # self.counter = self.get_current_frame()
+        # print(f"{self.current_animation}:{self.counter}/{self.animations[self.current_animation].duration_list_length}")
+        if self.counter >= self.animations[self.current_animation].duration_list_length:
+            #one animation cycle ended
+            if self.animation_loop > 0:
+                self.animation_loop -= 1
+            elif self.queued_animation is not None:
+                # print("set to queued :",self.queued_animation)
+                self.set_animation(self.queued_animation,True)
+
+            if self.end_callback:
+                self.end_callback()            
+ 
+    def draw(self, camera):
+        # print(self.current_animation, f"{self.counter}/{self.animations[self.current_animation].duration_list_length}")
+        self.surface = self.animations[self.current_animation].get_frame(self.counter,self.flipX)#,(0,0)
+        super().draw(camera)
         

batFramework/animation.py

@@ -1,77 +1,91 @@
-import pygame
-import batFramework as bf
-from typing import List, Dict, Tuple, Union, Optional, Self
-
-
-def search_index(target: int, lst: List[int]) -> int:
-    cumulative_sum = 0
-    for index, value in enumerate(lst):
-        cumulative_sum += value
-        if cumulative_sum >= target:
-            return index
-    return -1
-
-
-class Animation:
-    def __init__(
-        self,
-        name: str
-    ) -> None:
-        """
-        Class to hold 2D animation data.
-        All frames are expected to have the same size.
-        This class does not do anything on its own, but can be used to easily manage
-        multiple animations using a simple counter.
-        The duration list provides a entry point for tweaking the timings,
-        so image data can be saved (no need for contiguous duplicate frames)
-        """
-        self.name = name
-        self.frames: list[pygame.Surface] = []
-        self.frames_flipX : list[pygame.Surface] = []
-        self.duration_list = []
-        self.duration_list_length = 0 # prevents calling len() each frame
-        self.numFrames : int = 0
-
-    def from_surface(self,surface:pygame.Surface,frame_size : Tuple[int,int])->Self:
-        """
-        Loads frames from a spritesheet containing all animation frames aligned horizontally, left to right
-        Frames are cut and stored in 2 versions, original and flipped on the horizontal axis.
-        Flipping sprites being pretty common, this serves as a builtin cache.
-        """
-        self.frames : List[pygame.Surface] = list(
-            bf.utils.split_surface(surface, frame_size).values()
-        )
-        self.frames_flipX : List[pygame.Surface] = list(
-            bf.utils.split_surface(
-                surface, frame_size,
-                func=lambda s : pygame.transform.flip(s,True,False)
-            ).values()
-        )
-        self.duration_list_length = len(self.frames)
-        self.numFrames = self.duration_list_length
-        if not self.duration_list:
-            self.duration_list = [1]*self.duration_list_length
-        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
-        )
-
-    def get_frame(self, counter: Union[float, int], flip: bool) -> pygame.Surface:
-        i = self.counter_to_frame(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) != self.numFrames:
-            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
+import pygame
+import batFramework as bf
+from typing import List, Dict, Tuple, Union, Optional, Self, Iterable
+
+
+def search_index(target: int, lst: List[int]) -> int:
+    cumulative_sum = 0
+    for index, value in enumerate(lst):
+        cumulative_sum += value
+        if cumulative_sum >= target:
+            return index
+    return -1
+
+
+class Animation:
+    def __init__(
+        self,
+        name: str
+    ) -> None:
+        """
+        Class to hold 2D animation data.
+        All frames are expected to have the same size.
+        This class does not do anything on its own, but can be used to easily manage
+        multiple animations using a simple counter.
+        The duration list provides a entry point for tweaking the timings,
+        so image data can be saved (no need for contiguous duplicate frames)
+        """
+        self.name = name
+        self.frames: list[pygame.Surface] = []
+        self.frames_flipX : list[pygame.Surface] = []
+        self.duration_list = []
+        self.duration_list_length = 0
+        self.numFrames : int = 0
+
+    def from_surface(self,surface:pygame.Surface,frame_size : Tuple[int,int])->Self:
+        """
+        Loads frames from a spritesheet containing all animation frames aligned horizontally, left to right
+        Frames are cut and stored in 2 versions, original and flipped on the horizontal axis.
+        Flipping sprites being pretty common, this serves as a builtin cache.
+        """
+        self.frames : List[pygame.Surface] = list(
+            bf.utils.split_surface(surface, frame_size).values()
+        )
+        self.frames_flipX : List[pygame.Surface] = list(
+            bf.utils.split_surface(
+                surface, frame_size,
+                func=lambda s : pygame.transform.flip(s,True,False)
+            ).values()
+        )
+        self.duration_list_length = len(self.frames)
+        self.numFrames = self.duration_list_length
+        if not self.duration_list:
+            self.duration_list = [1]*self.duration_list_length
+        return self
+
+    def from_path(
+        self,
+        path: str,
+        frame_size: Tuple[int, int],
+        convert_alpha: bool = True
+    ) -> Self:
+        """
+        Loads frames from a spritesheet at the given path.
+        Uses ResourceManager to load the image.
+        """
+        surface = bf.ResourceManager().get_image(path, convert_alpha)
+        return self.from_surface(surface, frame_size)
+
+
+    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
+        )
+
+    def get_frame(self, counter: Union[float, int], flip: bool) -> pygame.Surface:
+        i = self.counter_to_frame(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 not isinstance(duration_list, Iterable):
+            duration_list = [duration_list] * len(self.frames)
+        if len(duration_list) != self.numFrames:
+            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