batframework 1.0.8a3__py3-none-any.whl → 1.0.8a4__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 *

batFramework/animatedSprite.py

@@ -1,8 +1,10 @@
 import batFramework as bf
 import pygame
+from typing import List, Dict, Tuple, Union, Optional
+from enum import Enum
 
 
-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
@@ -16,37 +18,34 @@ class AnimState:
         self,
         name: str,
         surface: pygame.Surface,
-        width,
-        height,
-        duration_list: list | int,
+        size: Tuple[int,int],
+        duration_list: Union[List[int], int],
     ) -> None:
-        self.frames: list[pygame.Surface] = list(
+        self.frames: List[pygame.Surface] = list(
             bf.utils.split_surface(
-                surface, width, height, False, convert_alpha
+                surface, size
             ).values()
         )
-        self.frames_flipX: list[pygame.Surface] = list(
-            bf.utils.split_surface(surface, width, height, True, convert_alpha).values()
+        self.frames_flipX: List[pygame.Surface] = list(
+            bf.utils.split_surface(surface, size,).values()
         )
 
         self.name = name
-        self.duration_list: list[int] = []
-        self.duration_list_length = 0
         self.set_duration_list(duration_list)
 
     def __repr__(self):
         return f"AnimState({self.name})"
 
-    def counter_to_frame(self, counter: float | int) -> int:
+    def counter_to_frame(self, counter: Union[float, int]) -> int:
         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]):
         if isinstance(duration_list, int):
             duration_list = [duration_list] * len(self.frames)
         if len(duration_list) != len(self.frames):
@@ -55,21 +54,23 @@ class AnimState:
         self.duration_list_length = sum(self.duration_list)
 
 
-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
+        self.animStates: Dict[str, AnimState] = {}
+        self.current_state: Optional[AnimState] = None
+        self.flipX: bool = False
+        self._locked: bool = False
+        self._paused: bool = False
 
-    def pause(self) -> None:
-        self.paused = True
+    @property
+    def paused(self) -> bool:
+        return self._paused
 
-    def resume(self) -> None:
-        self.paused = False
+    @paused.setter
+    def paused(self, value: bool) -> None:
+        self._paused = value
 
     def toggle_pause(self) -> None:
         self.paused = not self.paused
@@ -80,16 +81,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,16 +89,16 @@ 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:
+        if name not in self.animStates:
             return False
         self.animStates.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.animStates.values())[0] if self.animStates else None
             )
         return True
 
@@ -114,54 +106,56 @@ class AnimatedSprite(bf.DynamicEntity):
         self,
         name: str,
         surface: pygame.Surface,
-        size: tuple[int, int],
-        duration_list: list[int],
-        convert_alpha: bool = True,
+        size: Tuple[int, int],
+        duration_list: Union[List[int], int],
     ) -> bool:
         if name in self.animStates:
             return False
-        self.animStates[name] = AnimState(name, surface, *size, duration_list)
+        self.animStates[name] = AnimState(
+            name, surface, size, duration_list
+        )
         if len(self.animStates) == 1:
             self.set_animState(name)
         return True
 
-    def set_animState(self, state: str, reset_counter=True, lock=False) -> bool:
+    def set_animState(
+        self, state: str, reset_counter: bool = True, lock: bool = False
+    ) -> bool:
         if state not in self.animStates or self._locked:
             return False
 
         animState = self.animStates[state]
         self.current_state = animState
 
-        self.rect = self.current_state.frames[0].get_frect(center=self.rect.center)
+        self.rect = self.current_state.frames[0].get_rect(center=self.rect.center)
 
-        if reset_counter or self.float_counter > sum(animState.duration_list):
+        if reset_counter or self.float_counter > animState.duration_list_length:
             self.float_counter = 0
         if lock:
             self.lock()
         return True
 
-    def get_animState(self) -> AnimState | None:
+    def get_animState(self) -> Optional[AnimState]:
         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
+        if  self.animStates and s is not None:
+            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:
+    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),
             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/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,21 @@ 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)
 
-    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/gui/clickableWidget.py

@@ -141,7 +141,8 @@ 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)
@@ -149,7 +150,8 @@ class ClickableWidget(Shape, InteractiveWidget):
     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()
 

batFramework/gui/constraints/constraints.py

@@ -26,7 +26,11 @@ class Constraint:
 
     def apply_constraint(self, parent_widget: Widget, child_widget: Widget):
         raise NotImplementedError("Subclasses must implement apply_constraint method")
-
+    
+    def __eq__(self,other:"Constraint")->bool:
+        if not isinstance(other,self.__class__):
+            return False
+        return other.name == self.name
 
 class MinWidth(Constraint):
     def __init__(self, width: float):
@@ -39,6 +43,13 @@ class MinWidth(Constraint):
     def apply_constraint(self, parent_widget, child_widget):
         child_widget.set_size((self.min_width, None))
 
+    def __eq__(self,other:"Constraint")->bool:
+        if not isinstance(other,self.__class__):
+            return False
+        return (
+            other.name == self.name and
+            other.min_width == self.min_width
+        )
 
 class MinHeight(Constraint):
     def __init__(self, height: float):
@@ -51,6 +62,13 @@ class MinHeight(Constraint):
     def apply_constraint(self, parent_widget, child_widget):
         child_widget.set_size((None, self.min_height))
 
+    def __eq__(self,other:"Constraint")->bool:
+        if not isinstance(other,self.__class__):
+            return False
+        return (
+            other.name == self.name and
+            other.min_height == self.min_height
+        )
 
 class CenterX(Constraint):
     def __init__(self):
@@ -124,6 +142,14 @@ class PercentageWidth(Constraint):
             (round(parent_widget.get_padded_width() * self.percentage), None)
         )
 
+    def __eq__(self,other:"Constraint")->bool:
+        if not isinstance(other,self.__class__):
+            return False
+        return (
+            other.name == self.name and
+            other.percentage == self.percentage
+        )
+
 
 class PercentageHeight(Constraint):
     def __init__(self, percentage: float, keep_autoresize: bool = False):
@@ -151,18 +177,30 @@ class PercentageHeight(Constraint):
             (None, round(parent_widget.get_padded_height() * self.percentage))
         )
 
+    def __eq__(self,other:"Constraint")->bool:
+        if not isinstance(other,self.__class__):
+            return False
+        return (
+            other.name == self.name and
+            other.percentage == self.percentage
+        )
 
 class FillX(PercentageWidth):
     def __init__(self, keep_autoresize: bool = False):
         super().__init__(1, keep_autoresize)
         self.name = "fill_x"
 
+    def __eq__(self, other: Constraint) -> bool:
+        return Constraint.__eq__(self,other)
 
 class FillY(PercentageHeight):
     def __init__(self, keep_autoresize: bool = False):
         super().__init__(1, keep_autoresize)
         self.name = "fill_y"
 
+    def __eq__(self, other: Constraint) -> bool:
+        return Constraint.__eq__(self,other)
+
 
 class PercentageRectHeight(Constraint):
     def __init__(self, percentage: float, keep_autoresize: bool = False):
@@ -190,6 +228,13 @@ class PercentageRectHeight(Constraint):
             (None, round(parent_widget.rect.height * self.percentage))
         )
 
+    def __eq__(self,other:"Constraint")->bool:
+        if not isinstance(other,self.__class__):
+            return False
+        return (
+            other.name == self.name and
+            other.percentage == self.percentage
+        )
 
 class PercentageRectWidth(Constraint):
     def __init__(self, percentage: float, keep_autoresize: bool = False):
@@ -215,6 +260,13 @@ class PercentageRectWidth(Constraint):
             child_widget.set_autoresize_w(False)
         child_widget.set_size((round(parent_widget.rect.width * self.percentage), None))
 
+    def __eq__(self,other:"Constraint")->bool:
+        if not isinstance(other,self.__class__):
+            return False
+        return (
+            other.name == self.name and
+            other.percentage == self.percentage
+        )
 
 class FillRectX(PercentageRectWidth):
     def __init__(self, keep_autoresize: bool = False):
@@ -252,9 +304,10 @@ class AspectRatio(Constraint):
 
     def evaluate(self, parent_widget, child_widget):
         if self.ref_axis == bf.axis.HORIZONTAL:
-            return self.ratio == child_widget.rect.w / child_widget.rect.h
-        if self.ref_axis == bf.axis.VERTICAL:
             return self.ratio == child_widget.rect.h / child_widget.rect.w
+        if self.ref_axis == bf.axis.VERTICAL:
+            return self.ratio == child_widget.rect.w / child_widget.rect.h
+
 
     def apply_constraint(self, parent_widget, child_widget):
 
@@ -262,7 +315,7 @@ class AspectRatio(Constraint):
             if child_widget.autoresize_w:
                 if self.keep_autoresize:
                     print(
-                        f"WARNING: Constraint on {child_widget.__str__()} can't resize, autoresize set to True"
+                        f"WARNING: Constraint on {str(child_widget)} can't resize, autoresize set to True"
                     )
                     return
                 child_widget.set_autoresize_w(False)
@@ -272,13 +325,21 @@ class AspectRatio(Constraint):
             if child_widget.autoresize_h:
                 if self.keep_autoresize:
                     print(
-                        f"WARNING: Constraint on {child_widget.__str__()} can't resize, autoresize set to True"
+                        f"WARNING: Constraint on {str(child_widget)} can't resize, autoresize set to True"
                     )
                     return
                 child_widget.set_autoresize_h(False)
-            print("HERE")
+
             child_widget.set_size((None, child_widget.rect.w * self.ratio))
 
+    def __eq__(self,other:"Constraint")->bool:
+        if not isinstance(other,self.__class__):
+            return False
+        return (
+            other.name == self.name and
+            other.ratio == self.ratio and
+            other.ref_axis == self.ref_axis
+        )
 
 class AnchorBottom(Constraint):
     def __init__(self):
@@ -286,8 +347,8 @@ class AnchorBottom(Constraint):
 
     def evaluate(self, parent_widget, child_widget):
         return (
-            child_widget.rect.top
-            == parent_widget.get_padded_bottom() - child_widget.rect.h
+            child_widget.rect.bottom
+            == parent_widget.get_padded_bottom()
         )
 
     def apply_constraint(self, parent_widget, child_widget):
@@ -295,21 +356,15 @@ class AnchorBottom(Constraint):
             child_widget.rect.x, parent_widget.get_padded_bottom() - child_widget.rect.h
         )
 
-
-class AnchorBottom(Constraint):
+class AnchorTop(Constraint):
     def __init__(self):
-        super().__init__(name="anchor_bottom")
+        super().__init__(name="anchor_top")
 
     def evaluate(self, parent_widget, child_widget):
-        return (
-            child_widget.rect.top
-            == parent_widget.get_padded_bottom() - child_widget.rect.h
-        )
+        return (child_widget.rect.top == parent_widget.get_padded_top())
 
     def apply_constraint(self, parent_widget, child_widget):
-        child_widget.set_position(
-            child_widget.rect.x, parent_widget.get_padded_bottom() - child_widget.rect.h
-        )
+        child_widget.set_position(child_widget.rect.x, parent_widget.get_padded_top())
 
 
 class AnchorTopRight(Constraint):
@@ -385,6 +440,13 @@ class MarginBottom(Constraint):
             parent_widget.get_padded_bottom() - child_widget.rect.h - self.margin,
         )
 
+    def __eq__(self,other:"Constraint")->bool:
+        if not isinstance(other,self.__class__):
+            return False
+        return (
+            other.name == self.name and
+            other.margin == self.margin
+        )
 
 class MarginTop(Constraint):
     def __init__(self, margin: float):
@@ -399,6 +461,13 @@ class MarginTop(Constraint):
             child_widget.rect.x, parent_widget.get_padded_top() + self.margin
         )
 
+    def __eq__(self,other:"Constraint")->bool:
+        if not isinstance(other,self.__class__):
+            return False
+        return (
+            other.name == self.name and
+            other.margin == self.margin
+        )
 
 class MarginLeft(Constraint):
     def __init__(self, margin: float):
@@ -414,6 +483,13 @@ class MarginLeft(Constraint):
                 parent_widget.get_padded_left() + self.margin, child_widget.rect.y
             )
 
+    def __eq__(self,other:"Constraint")->bool:
+        if not isinstance(other,self.__class__):
+            return False
+        return (
+            other.name == self.name and
+            other.margin == self.margin
+        )
 
 class MarginRight(Constraint):
     def __init__(self, margin: float):
@@ -429,6 +505,13 @@ class MarginRight(Constraint):
             child_widget.rect.y,
         )
 
+    def __eq__(self,other:"Constraint")->bool:
+        if not isinstance(other,self.__class__):
+            return False
+        return (
+            other.name == self.name and
+            other.margin == self.margin
+        )
 
 class PercentageMarginBottom(Constraint):
     def __init__(self, margin: float):
@@ -450,6 +533,13 @@ class PercentageMarginBottom(Constraint):
             - parent_widget.get_padded_height() * self.margin,
         )
 
+    def __eq__(self,other:"Constraint")->bool:
+        if not isinstance(other,self.__class__):
+            return False
+        return (
+            other.name == self.name and
+            other.margin == self.margin
+        )
 
 class PercentageMarginTop(Constraint):
     def __init__(self, margin: float):
@@ -470,6 +560,13 @@ class PercentageMarginTop(Constraint):
             + parent_widget.get_padded_height() * self.margin,
         )
 
+    def __eq__(self,other:"Constraint")->bool:
+        if not isinstance(other,self.__class__):
+            return False
+        return (
+            other.name == self.name and
+            other.margin == self.margin
+        )
 
 class PercentageMarginLeft(Constraint):
     def __init__(self, margin: float):
@@ -491,6 +588,13 @@ class PercentageMarginLeft(Constraint):
                 child_widget.rect.y,
             )
 
+    def __eq__(self,other:"Constraint")->bool:
+        if not isinstance(other,self.__class__):
+            return False
+        return (
+            other.name == self.name and
+            other.margin == self.margin
+        )
 
 class PercentageMarginRight(Constraint):
     def __init__(self, margin: float):
@@ -512,6 +616,13 @@ class PercentageMarginRight(Constraint):
             child_widget.rect.y,
         )
 
+    def __eq__(self,other:"Constraint")->bool:
+        if not isinstance(other,self.__class__):
+            return False
+        return (
+            other.name == self.name and
+            other.margin == self.margin
+        )
 
 class PercentageRectMarginBottom(Constraint):
     def __init__(self, margin: float):
@@ -532,6 +643,13 @@ class PercentageRectMarginBottom(Constraint):
             - parent_widget.rect.height * self.margin,
         )
 
+    def __eq__(self,other:"Constraint")->bool:
+        if not isinstance(other,self.__class__):
+            return False
+        return (
+            other.name == self.name and
+            other.margin == self.margin
+        )
 
 class PercentageRectMarginTop(Constraint):
     def __init__(self, margin: float):
@@ -550,6 +668,13 @@ class PercentageRectMarginTop(Constraint):
             parent_widget.rect.top + parent_widget.rect.height * self.margin,
         )
 
+    def __eq__(self,other:"Constraint")->bool:
+        if not isinstance(other,self.__class__):
+            return False
+        return (
+            other.name == self.name and
+            other.margin == self.margin
+        )
 
 class PercentageRectMarginLeft(Constraint):
     def __init__(self, margin: float):
@@ -569,6 +694,13 @@ class PercentageRectMarginLeft(Constraint):
                 child_widget.rect.y,
             )
 
+    def __eq__(self,other:"Constraint")->bool:
+        if not isinstance(other,self.__class__):
+            return False
+        return (
+            other.name == self.name and
+            other.margin == self.margin
+        )
 
 class PercentageRectMarginRight(Constraint):
     def __init__(self, margin: float):
@@ -588,3 +720,11 @@ class PercentageRectMarginRight(Constraint):
             - parent_widget.rect.width * self.margin,
             child_widget.rect.y,
         )
+
+    def __eq__(self,other:"Constraint")->bool:
+        if not isinstance(other,self.__class__):
+            return False
+        return (
+            other.name == self.name and
+            other.margin == self.margin
+        )