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

batFramework/__init__.py

@@ -24,12 +24,15 @@ from .dynamicEntity import DynamicEntity
 from .sprite import Sprite
 from .scrollingSprite import ScrollingSprite
 from .particle import *
-from .animatedSprite import AnimatedSprite, AnimState
+from .animatedSprite import AnimatedSprite, Animation
+from .character import Character
 from .stateMachine import State, StateMachine
 from .scene import Scene
 from .gui import *
 from .sceneManager import SceneManager
 from .manager import Manager
+from .templates import *
+import importlib.metadata
 
 
 def init_screen(resolution: tuple[int, int], flags: int = 0, vsync: int = 0):
@@ -44,6 +47,16 @@ def init_screen(resolution: tuple[int, int], flags: int = 0, vsync: int = 0):
     )
 
 
+
+def print_version():
+    package_name = "batFramework"
+    try:
+        version = importlib.metadata.version(package_name)
+        print(f"{package_name} version: {version}")
+    except importlib.metadata.PackageNotFoundError:
+        print(f"{package_name} is not installed")
+
+
 def init(
     resolution: tuple[int, int],
     flags: int = 0,
@@ -54,6 +67,7 @@ def init(
     window_title: str = "BatFramework Project",
     fps_limit: int = 0,
 ):
+    print_version()
     pygame.display.set_caption(window_title)
     init_screen(resolution, flags, vsync)
 

batFramework/animatedSprite.py

@@ -1,7 +1,6 @@
 import batFramework as bf
 import pygame
-from typing import List, Dict, Tuple, Union, Optional
-from enum import Enum
+from typing import List, Dict, Tuple, Union, Optional, Self
 
 
 def search_index(target: int, lst: List[int]) -> int:
@@ -13,30 +12,28 @@ def search_index(target: int, lst: List[int]) -> int:
     return -1
 
 
-class AnimState:
+class Animation:
     def __init__(
         self,
-        name: str,
-        surface: pygame.Surface,
-        size: Tuple[int,int],
-        duration_list: Union[List[int], int],
+        name: str
     ) -> None:
-        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,).values()
-        )
-
         self.name = name
-        self.set_duration_list(duration_list)
+        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"AnimState({self.name})"
+        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
         )
@@ -45,24 +42,30 @@ class AnimState:
         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]):
+    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:
         super().__init__(size, no_surface=True)
         self.float_counter: float = 0
-        self.animStates: Dict[str, AnimState] = {}
-        self.current_state: Optional[AnimState] = None
+        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:
@@ -92,60 +95,72 @@ class AnimatedSprite(bf.Entity):
     def set_flipX(self, value: bool) -> None:
         self.flipX = value
 
-    def remove_animState(self, name: str) -> bool:
-        if name not in self.animStates:
+    def remove_animation(self, name: str) -> bool:
+        if name not in self.animations:
             return False
-        self.animStates.pop(name)
+        self.animations.pop(name)
         if self.current_state and self.current_state.name == name:
             self.current_state = (
-                list(self.animStates.values())[0] if self.animStates else None
+                list(self.animations.values())[0] if self.animations else None
             )
         return True
 
-    def add_animState(
+    def add_animation(
         self,
-        name: str,
-        surface: pygame.Surface,
-        size: Tuple[int, int],
-        duration_list: Union[List[int], int],
+        animation:Animation
     ) -> bool:
-        if name in self.animStates:
+        if animation.name in self.animations:
             return False
-        self.animStates[name] = AnimState(
-            name, surface, size, duration_list
-        )
-        if len(self.animStates) == 1:
-            self.set_animState(name)
+        self.animations[animation.name] = animation
         return True
 
-    def set_animState(
+    def set_animation(
         self, state: str, reset_counter: bool = True, lock: bool = False
     ) -> bool:
-        if state not in self.animStates or self._locked:
+        if state not in self.animations or self._locked:
             return False
+        
+        animation = self.animations[state]
+        self.current_state = animation
 
-        animState = self.animStates[state]
-        self.current_state = animState
-
-        self.rect = self.current_state.frames[0].get_rect(center=self.rect.center)
+        if self.current_state.frames:
+            self.rect = self.current_state.frames[0].get_frect(center=self.rect.center)
 
-        if reset_counter or self.float_counter > animState.duration_list_length:
+        if reset_counter or (self.float_counter > animation.duration_list_length):
             self.float_counter = 0
+
         if lock:
             self.lock()
+        
+        if self.transition_end_animation is not None:
+            self.transition_end_animation = None
         return True
-
-    def get_animState(self) -> Optional[AnimState]:
+    
+    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_animState()
-        if  self.animStates and s is not 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
-        self.do_update(dt)
+        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 (
@@ -155,7 +170,7 @@ class AnimatedSprite(bf.Entity):
         ):
             return
         camera.surface.blit(
-            self.current_state.get_frame(self.float_counter, self.flipX),
+            self.get_current_frame(),
             camera.world_to_screen(self.rect),
         )
         return 

batFramework/character.py

@@ -0,0 +1,27 @@
+import batFramework as bf
+from .stateMachine import State
+from .animatedSprite import AnimatedSprite
+from .dynamicEntity import DynamicEntity
+
+class Character(AnimatedSprite,DynamicEntity):
+    def __init__(self) -> None:
+        super().__init__()
+        self.state_machine = bf.StateMachine(self)
+        self.do_setup_animations()
+        self.do_setup_states()
+
+    def set_state(self,state_name:str):
+        self.state_machine.set_state(state_name)
+
+    def get_current_state(self)->State:
+        return self.state_machine.get_current_state()
+    
+    def update(self, dt: float) -> None:
+        self.state_machine.update(dt)
+        super().update(dt)
+
+    def do_setup_states(self):
+        pass
+    
+    def do_setup_animations(self):
+        pass

batFramework/dynamicEntity.py

@@ -12,6 +12,7 @@ class DynamicEntity(bf.Entity):
     ) -> None:
         super().__init__(size, surface_flags, convert_alpha,*args,**kwargs)
         self.velocity = pygame.math.Vector2(0, 0)
+        self.ignore_collisions : bool = False
 
     def on_collideX(self, collider: "DynamicEntity"):
         """

batFramework/enums.py

@@ -51,7 +51,7 @@ class easing(Enum):
     EASE_IN = (0.95, 0, 1, 0.55)
     EASE_OUT = (0.5, 1, 0.5, 1)
     EASE_IN_OUT = (0.55, 0, 0.45, 1)
-    EASE_IN_OUT_ELASTIC = (0.39, -0.55, 0.3, 1.3)
+    EASE_IN_OUT_ELASTIC = (0.76,-0.36,0.41,1.34)
 
     def __init__(self, *control_points):
         self.control_points = control_points
@@ -110,4 +110,4 @@ class actionType(Enum):
 class textMode(Enum):
     ALPHABETICAL = 0
     NUMERICAL = 1
-    ALPHANUMERIC = 3
+    ALPHANUMERICAL = 3

batFramework/fontManager.py

@@ -42,7 +42,7 @@ class FontManager(metaclass=Singleton):
             filename = name  # if name is not given, name is the filename
         self.FONTS[filename] = {}
         # fill the dict
-        for size in range(self.MIN_FONT_SIZE, self.MAX_FONT_SIZE, 2):
+        for size in range(self.MIN_FONT_SIZE, self.MAX_FONT_SIZE+1, 2):
             self.FONTS[filename][size] = pygame.font.Font(path, size=size)
 
     def load_sysfont(self, font_name: str | None, key: str | None = ""):
@@ -52,7 +52,7 @@ class FontManager(metaclass=Singleton):
             raise FileNotFoundError(f"Requested font '{font_name}' was not found")
         self.FONTS[font_name] = {}
 
-        for size in range(self.MIN_FONT_SIZE, self.MAX_FONT_SIZE, 2):
+        for size in range(self.MIN_FONT_SIZE, self.MAX_FONT_SIZE+1, 2):
             self.FONTS[key][size] = pygame.font.SysFont(font_name, size=size)
 
     def get_font(

batFramework/gui/clickableWidget.py

@@ -27,7 +27,7 @@ class ClickableWidget(Shape, InteractiveWidget):
         self.set_debug_color("cyan")
         self.set_relief(self.unpressed_relief)
 
-    def set_unpressed_relief(self, relief: int = 0) -> Self:
+    def set_unpressed_relief(self, relief: int) -> Self:
         if relief == self.unpressed_relief:
             return self
         self.unpressed_relief = relief
@@ -36,18 +36,17 @@ class ClickableWidget(Shape, InteractiveWidget):
             self.set_relief(relief)
         return self
 
-    def set_silent_focus(self, value: bool) -> Self:
-        self.silent_focus = value
-        return self
-
-    def set_pressed_relief(self, relief: int = 0) -> Self:
+    def set_pressed_relief(self, relief: int) -> Self:
         if relief == self.pressed_relief:
             return self
         self.pressed_relief = relief
         self.dirty_shape = True
         if self.is_pressed:
             self.set_relief(relief)
+        return self
 
+    def set_silent_focus(self, value: bool) -> Self:
+        self.silent_focus = value
         return self
 
     def set_click_down_sound(self, sound_name: str) -> Self:
@@ -143,7 +142,6 @@ class ClickableWidget(Shape, InteractiveWidget):
             self.is_pressed = True
             if self.click_down_sound:
                 bf.AudioManager().play_sound(self.click_down_sound)
-
             pygame.mouse.set_cursor(self.click_cursor)
             self.set_relief(self.pressed_relief)
 
@@ -219,3 +217,4 @@ class ClickableWidget(Shape, InteractiveWidget):
             self._paint_disabled()
         elif self.is_hovered:
             self._paint_hovered()
+