batframework 1.0.8a3__py3-none-any.whl → 1.0.8a6__py3-none-any.whl

batFramework/__init__.py

@@ -8,7 +8,7 @@ from .resourceManager import ResourceManager
 from .fontManager import FontManager
 from .utils import Utils as utils
 from .tileset import Tileset
-from .time import TimeManager, Timer
+from .time import *
 from .easingController import EasingController
 from .cutscene import Cutscene, CutsceneManager
 from .cutsceneBlocks import *
@@ -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,8 +1,9 @@
 import batFramework as bf
 import pygame
+from typing import List, Dict, Tuple, Union, Optional, Self
 
 
-def search_index(target, lst):
+def search_index(target: int, lst: List[int]) -> int:
     cumulative_sum = 0
     for index, value in enumerate(lst):
         cumulative_sum += value
@@ -11,65 +12,68 @@ def search_index(target, lst):
     return -1
 
 
-class AnimState:
+class Animation:
     def __init__(
         self,
-        name: str,
-        surface: pygame.Surface,
-        width,
-        height,
-        duration_list: list | int,
+        name: str
     ) -> None:
-        self.frames: list[pygame.Surface] = list(
-            bf.utils.split_surface(
-                surface, width, height, False, convert_alpha
-            ).values()
-        )
-        self.frames_flipX: list[pygame.Surface] = list(
-            bf.utils.split_surface(surface, width, height, True, convert_alpha).values()
-        )
-
         self.name = name
-        self.duration_list: list[int] = []
-        self.duration_list_length = 0
-        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: float | int) -> int:
+    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, flip):
+    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: 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.DynamicEntity):
-    def __init__(self, size=None) -> None:
+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: AnimState | None = None
-        self.flipX = False
-        self._locked = False
-        self.paused: bool = False
-
-    def pause(self) -> None:
-        self.paused = True
-
-    def resume(self) -> None:
-        self.paused = False
+        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
@@ -80,16 +84,7 @@ class AnimatedSprite(bf.DynamicEntity):
     def set_frame(self, frame_index: int) -> None:
         if not self.current_state:
             return
-        total = sum(self.current_state.duration_list)
-        frame_index = max(0, min(total, frame_index))
-        new_counter = 0
-        i = 0
-        while frame_index < total:
-            if self.current_state.counter_to_frame(new_counter) >= frame_index:
-                break
-            new_counter += self.current_state.duration_list[i]
-            i += 1
-        self.set_counter(new_counter)
+        self.set_counter(sum(self.current_state.duration_list[:frame_index]))
 
     def lock(self) -> None:
         self._locked = True
@@ -97,71 +92,85 @@ class AnimatedSprite(bf.DynamicEntity):
     def unlock(self) -> None:
         self._locked = False
 
-    def set_flipX(self, value) -> None:
+    def set_flipX(self, value: bool) -> None:
         self.flipX = value
 
-    def remove_animState(self, name: str) -> bool:
-        if not name 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_animState = (
-                list(self.animStates.keys())[0] if self.animStates else ""
+            self.current_state = (
+                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: list[int],
-        convert_alpha: bool = True,
+        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(self, state: str, reset_counter=True, lock=False) -> bool:
-        if state not in self.animStates or self._locked:
+    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
 
-        animState = self.animStates[state]
-        self.current_state = animState
-
-        self.rect = self.current_state.frames[0].get_frect(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 > sum(animState.duration_list):
+        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) -> AnimState | None:
+    
+    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 not self.animStates or s is None:
-            return
-        if not self.paused:
-            self.float_counter += 60 * dt
-            if self.float_counter > s.duration_list_length:
-                self.float_counter = 0
-        self.do_update(dt)
-
-    def draw(self, camera: bf.Camera) -> int:
+        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 0
+            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 1
+        return 

batFramework/audioManager.py

@@ -68,7 +68,7 @@ class AudioManager(metaclass=bf.Singleton):
             self.sounds[name]["sound"].play()
             return True
         except KeyError:
-            # print(f"Sound '{name}' not loaded in AudioManager.")
+            print(f"Sound '{name}' not loaded in AudioManager.")
             return False
 
     def stop_sound(self, name) -> bool:
@@ -77,7 +77,7 @@ class AudioManager(metaclass=bf.Singleton):
             return True
         except KeyError:
             return False
-            # print(f"Sound '{name}' not loaded in AudioManager.")
+            print(f"Sound '{name}' not loaded in AudioManager.")
 
     def load_music(self, name, path):
         self.musics[name] = bf.ResourceManager().get_path(path)

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/cutscene.py

@@ -1,8 +1,11 @@
 import batFramework as bf
-
+from typing import TYPE_CHECKING
 
 class CutsceneBlock: ...
 
+if TYPE_CHECKING:
+    from .cutsceneBlocks import CutsceneBlock
+
 
 class Cutscene: ...
 
@@ -58,7 +61,7 @@ class CutsceneManager(metaclass=bf.Singleton):
 
 class Cutscene:
     def __init__(self) -> None:
-        self.cutscene_blocks = []
+        self.cutscene_blocks : list[CutsceneBlock] = []
         self.block_index = 0
         self.end_blocks: list[CutsceneBlock] = []
         self.ended = False

batFramework/cutsceneBlocks.py

@@ -1,7 +1,7 @@
 import batFramework as bf
 from .cutscene import Cutscene, CutsceneManager
 from .transition import *
-
+from typing import Optional,Callable
 
 # Define the base CutsceneBlock class
 class CutsceneBlock:
@@ -150,7 +150,6 @@ class SceneTransitionBlock(CutsceneBlock):
         # Start the timer to handle the end of the transition
         self.timer.start()
 
-
 class DelayBlock(CutsceneBlock):
     def __init__(self, duration) -> None:
         super().__init__()
@@ -160,12 +159,11 @@ class DelayBlock(CutsceneBlock):
         super().start()
         self.timer.start()
 
-
 class FunctionBlock(CutsceneBlock):
-    def __init__(self, func) -> None:
+    def __init__(self, func : Optional[Callable]) -> None:
         self.function = func
 
     def start(self):
         super().start()
-        self.function()
+        if self.function : self.function()
         self.end()

batFramework/dynamicEntity.py

@@ -8,15 +8,22 @@ class DynamicEntity(bf.Entity):
         self,
         size: None | tuple[int, int] = None,
         surface_flags: int = 0,
-        convert_alpha: bool = False,
+        convert_alpha: bool = False,*args,**kwargs
     ) -> None:
-        super().__init__(size, surface_flags, convert_alpha)
+        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: Self):
+    def on_collideX(self, collider: "DynamicEntity"):
+        """
+        Return true if collision
+        """
         return False
 
-    def on_collideY(self, collider: Self):
+    def on_collideY(self, collider: "DynamicEntity"):
+        """
+        Return true if collision
+        """
         return False
 
     def move_by_velocity(self, dt) -> None:

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:
@@ -141,15 +140,16 @@ class ClickableWidget(Shape, InteractiveWidget):
             if not self.get_focus():
                 return
             self.is_pressed = True
-            bf.AudioManager().play_sound(self.click_down_sound)
-
+            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)
 
     def do_on_click_up(self, button) -> None:
         if self.enabled and button == 1 and self.is_pressed:
             self.is_pressed = False
-            bf.AudioManager().play_sound(self.click_up_sound)
+            if self.click_up_sound:
+                bf.AudioManager().play_sound(self.click_up_sound)
             self.set_relief(self.unpressed_relief)
             self.click()
 
@@ -217,3 +217,4 @@ class ClickableWidget(Shape, InteractiveWidget):
             self._paint_disabled()
         elif self.is_hovered:
             self._paint_hovered()
+