batframework 1.0.8a3__tar.gz → 1.0.8a4__tar.gz

{batframework-1.0.8a3/src/batframework.egg-info → batframework-1.0.8a4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: batframework
-Version: 1.0.8a3
+Version: 1.0.8a4
 Summary: Pygame framework for making games easier.
 Author-email: Turan Baturay <baturayturan@gmail.com>
 Project-URL: Homepage, https://github.com/TuranBaturay/batFramework

{batframework-1.0.8a3 → batframework-1.0.8a4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "batframework"
-version = "1.0.8a3"
+version = "1.0.8a4"
 authors = [
     { name="Turan Baturay", email="baturayturan@gmail.com" }
 ]

{batframework-1.0.8a3 → batframework-1.0.8a4}/src/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-1.0.8a3 → batframework-1.0.8a4}/src/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-1.0.8a3 → batframework-1.0.8a4}/src/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-1.0.8a3 → batframework-1.0.8a4}/src/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-1.0.8a3 → batframework-1.0.8a4}/src/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-1.0.8a3 → batframework-1.0.8a4}/src/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-1.0.8a3 → batframework-1.0.8a4}/src/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()