batframework 1.0.6__py3-none-any.whl → 1.0.8a1__py3-none-any.whl

batFramework/audioManager.py

@@ -5,19 +5,26 @@ pygame.mixer.init()
 
 
 class AudioManager(metaclass=bf.Singleton):
-    def __init__(self)->None:
+    def __init__(self) -> None:
         self.sounds: dict = {}
         self.musics: dict = {}
-        self.current_music :str|None= None
-        self.music_volume :float= 1
-        self.sound_volume :float= 1
+        self.current_music: str | None = None
+        self.music_volume: float = 1
+        self.sound_volume: float = 1
         pygame.mixer_music.set_endevent(bf.const.MUSIC_END_EVENT)
 
-    def free_sounds(self, force:bool=False):
+    def free_sounds(self, force: bool = False):
         if force:
             self.sounds = {}
             return
-        self.sounds =  {key:value for key,value in self.sounds.items() if value["persistent"]}
+        self.sounds: dict = {
+            key: value for key, value in self.sounds.items() if value["persistent"]
+        }
+
+    def free_music(self):
+        if self.current_music:
+            pygame.mixer.music.unload(self.current_music)
+            
 
     def set_sound_volume(self, volume: float):
         self.sound_volume = volume
@@ -26,7 +33,13 @@ class AudioManager(metaclass=bf.Singleton):
         self.music_volume = volume
         pygame.mixer_music.set_volume(volume)
 
-    def has_sound(self, name:str):
+    def get_music_volume(self) -> float:
+        return self.music_volume
+
+    def get_sound_volume(self) -> float:
+        return self.sound_volume
+
+    def has_sound(self, name: str):
         return name in self.sounds
 
     def load_sound(self, name, path, persistent=False) -> pygame.mixer.Sound:
@@ -36,44 +49,61 @@ class AudioManager(metaclass=bf.Singleton):
         self.sounds[name] = {
             "path": path,
             "sound": pygame.mixer.Sound(path),
-            "persistent": persistent
+            "persistent": persistent,
         }
         return self.sounds[name]["sound"]
 
-    def load_sounds(self,sound_data_list:list[tuple[str,str,bool]])->None:
+    def load_sounds(self, sound_data_list: list[tuple[str, str, bool]]) -> None:
         for data in sound_data_list:
             self.load_sound(*data)
-        return 
-        
-    def play_sound(self, name, volume=1):
+        return
+
+    def play_sound(self, name, volume=1) -> bool:
+        """
+        Play the sound file with the given name.
+        returns True if the sound was played
+
+        """
         try:
             self.sounds[name]["sound"].set_volume(volume * self.sound_volume)
             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):
+    def stop_sound(self, name) -> bool:
         try:
             self.sounds[name]["sound"].stop()
+            return True
         except KeyError:
-            
-            print(f"Sound '{name}' not loaded in AudioManager.")
+            return False
+            # print(f"Sound '{name}' not loaded in AudioManager.")
+
     def load_music(self, name, path):
         self.musics[name] = bf.ResourceManager().get_path(path)
         return
-        
-    def load_musics(self,music_data_list:list[tuple[str,str]]):
+
+    def load_musics(self, music_data_list: list[tuple[str, str]]):
         for data in music_data_list:
             self.load_music(*data)
         return
-        
-    def play_music(self, name, loop=0, fade=500):
+
+    def play_music(self, name, loop=0, fade=500) -> bool:
+        """
+        Play the sound file with the given 'name'.
+        Fades with the given 'fade' time in ms.
+        Music will loop 'loop' times (indefinitely if -1).
+        returns True if the sound was played
+        """
         try:
             pygame.mixer_music.load(self.musics[name])
             pygame.mixer_music.play(loop, fade_ms=fade)
             self.current_music = name
+            return True
         except KeyError:
-            print(f"Music '{name}' not loaded in AudioManager.")
+            return False
+            # print(f"Music '{name}' not loaded in AudioManager.")
 
     def stop_music(self):
         if not self.current_music:
@@ -95,5 +125,5 @@ class AudioManager(metaclass=bf.Singleton):
             return
         pygame.mixer_music.unpause()
 
-    def get_current_music(self)->str|None:
+    def get_current_music(self) -> str | None:
         return self.current_music

batFramework/camera.py

@@ -1,12 +1,13 @@
 import pygame
 from pygame.math import Vector2
-import math
 import batFramework as bf
+from typing import Self
 
 
 class Camera:
-
-    def __init__(self, flags=0, size: tuple[int,int] | None = None,convert_alpha:bool=False) -> None:
+    def __init__(
+        self, flags=0, size: tuple[int, int] | None = None, convert_alpha: bool = False
+    ) -> None:
         """
         Initialize the Camera object.
 
@@ -15,28 +16,30 @@ class Camera:
             size (tuple): Optional size for camera (defaults to window size)
             convert_alpha (bool): Convert surface to support alpha values
         """
-        size = size if size else bf.const.RESOLUTION
-        self.should_convert_alpha :bool = convert_alpha
-        self.rect = pygame.FRect(0, 0, *size)
-        self.vector_center = Vector2(0,0) 
-        
-        self.surface: pygame.Surface = pygame.Surface((0, 0)) #tmp dummy
+        self.cached_surfaces: dict[tuple[int, int], pygame.Surface] = {}
+
+        self.target_size = size if size else bf.const.RESOLUTION
+        self.should_convert_alpha: bool = convert_alpha
+        self.rect = pygame.FRect(0, 0, *self.target_size)
+        self.vector_center = Vector2(0, 0)
+
+        self.surface: pygame.Surface = pygame.Surface((0, 0))  # tmp dummy
         self.flags: int = flags | (pygame.SRCALPHA if convert_alpha else 0)
         self.blit_special_flags: int = pygame.BLEND_ALPHA_SDL2
-        
-        self._clear_color: pygame.Color = pygame.Color(0, 0, 0, 0 if convert_alpha else 255)
-        
-        self.cached_surfaces: dict[float, pygame.Surface] = {}
-        
+
+        self._clear_color: pygame.Color = pygame.Color(0, 0, 0, 0)
+        if not convert_alpha:
+            self._clear_color = pygame.Color(0, 0, 0)
+
         self.follow_point_func = None
-        self.follow_speed :float= 0.1 
-        
+        self.follow_friction: float = 0.5
+
         self.zoom_factor = 1
         self.max_zoom = 2
         self.min_zoom = 0.1
         self.zoom(1)
 
-    def set_clear_color(self, color: pygame.Color | tuple | str) -> "Camera":
+    def set_clear_color(self, color: pygame.Color | tuple | str) -> Self:
         """
         Set the clear color for the camera surface.
 
@@ -46,12 +49,10 @@ class Camera:
         Returns:
             Camera: Returns the Camera object.
         """
-        if not isinstance(color, pygame.Color):
-            color = pygame.Color(color)
         self._clear_color = color
         return self
 
-    def set_max_zoom(self, value: float) -> "Camera":
+    def set_max_zoom(self, value: float) -> Self:
         """
         Set the maximum zoom value for the camera.
 
@@ -64,7 +65,7 @@ class Camera:
         self.max_zoom = value
         return self
 
-    def set_min_zoom(self, value: float) -> "Camera":
+    def set_min_zoom(self, value: float) -> Self:
         """
         Set the minimum zoom value for the camera.
 
@@ -83,7 +84,7 @@ class Camera:
         """
         self.surface.fill(self._clear_color)
 
-    def get_center(self) -> tuple[float,float]:
+    def get_center(self) -> tuple[float, float]:
         """
         Get the center of the camera's view.
 
@@ -92,7 +93,7 @@ class Camera:
         """
         return self.rect.center
 
-    def get_position(self) -> tuple[float,float]:
+    def get_position(self) -> tuple[float, float]:
         """
         Get the center of the camera's view.
 
@@ -101,7 +102,7 @@ class Camera:
         """
         return self.rect.topleft
 
-    def move_by(self, x : float|int, y:float|int) -> "Camera":
+    def move_by(self, x: float | int, y: float | int) -> Self:
         """
         Moves the camera rect by the given coordinates.
 
@@ -113,10 +114,9 @@ class Camera:
             Camera: Returns the Camera object.
         """
         self.rect.move_ip(x, y)
-        self.vector_center.update(self.rect.center)
         return self
 
-    def set_position(self, x, y) -> "Camera":
+    def set_position(self, x, y) -> Self:
         """
         Set the camera rect top-left position.
 
@@ -128,11 +128,10 @@ class Camera:
             Camera: Returns the Camera object.
         """
         self.rect.topleft = (x, y)
-        self.vector_center.update(self.rect.center)
 
         return self
 
-    def set_center(self, x, y) -> "Camera":
+    def set_center(self, x, y) -> Self:
         """
         Set the camera rect center position.
 
@@ -144,10 +143,9 @@ class Camera:
             Camera: Returns the Camera object.
         """
         self.rect.center = (x, y)
-        self.vector_center.update(self.rect.center)
         return self
 
-    def set_follow_point(self, func,follow_speed :float = 0.1) -> "Camera":
+    def set_follow_point(self, func, follow_speed: float = 0.1) -> Self:
         """
         Set the following function (returns tuple x y).
         Camera will center its position to the center of the given coordinates.
@@ -159,10 +157,14 @@ class Camera:
             Camera: Returns the Camera object.
         """
         self.follow_point_func = func
-        self.follow_speed =  follow_speed if func else 0.1
+        self.follow_speed = follow_speed if func else 0.1
         return self
 
-    def zoom_by(self, amount: float) -> "Camera":
+    def set_follow_friction(self,friction:float)->Self:
+        self.follow_friction = friction
+        return self
+
+    def zoom_by(self, amount: float) -> Self:
         """
         Zooms the camera by the given amount.
 
@@ -172,10 +174,10 @@ class Camera:
         Returns:
             Camera: Returns the Camera object.
         """
-        self.zoom(self.zoom_factor + amount)
+        self.zoom(max(self.min_zoom, min(self.max_zoom, self.zoom_factor + amount)))
         return self
 
-    def zoom(self, factor) -> "Camera":
+    def zoom(self, factor: float) -> Self:
         """
         Zooms the camera to the given factor.
 
@@ -186,26 +188,41 @@ class Camera:
             Camera: Returns the Camera object.
         """
         if factor < self.min_zoom or factor > self.max_zoom:
+            print(
+                f"Zoom value {factor} is outside the zoom range : [{self.min_zoom},{self.max_zoom}]"
+            )
             return self
 
         factor = round(factor, 2)
         self.zoom_factor = factor
-
-        if factor not in self.cached_surfaces:
-            self.cached_surfaces[factor] = pygame.Surface(
-                tuple(i / factor for i in bf.const.RESOLUTION), flags=self.flags
-            )
-            if self.should_convert_alpha :
-                self.cached_surfaces[factor].convert_alpha()
-            else:
-                self.cached_surfaces[factor].convert()
-            # self.cached_surfaces[factor].fill((self._clear_color))
-
-        self.surface = self.cached_surfaces[self.zoom_factor]
+        new_res = tuple(round((i / factor) / 2) * 2 for i in self.target_size)
+        self.surface = self._get_cached_surface(new_res)
         self.rect = self.surface.get_frect(center=self.rect.center)
         self.clear()
         return self
 
+    def _free_cache(self):
+        self.cached_surfaces = {}
+
+    def _get_cached_surface(self, new_size: tuple[int, int]):
+        surface = self.cached_surfaces.get(new_size, None)
+        if surface is None:
+            surface = pygame.Surface(new_size, flags=self.flags)
+            if self.flags & pygame.SRCALPHA:
+                surface = surface.convert_alpha()
+            self.cached_surfaces[new_size] = surface
+
+        return surface
+
+    def resize(self, size: tuple[int, int] | None = None) -> Self:
+        if size is None:
+            size = bf.const.RESOLUTION
+        self.target_size = size
+        self.rect.center = (size[0] / 2, size[1] / 2)
+        self.zoom(self.zoom_factor)
+
+        return self
+
     def intersects(self, rect: pygame.Rect | pygame.FRect) -> bool:
         """
         Check if the camera view intersects with the given rectangle.
@@ -216,53 +233,51 @@ class Camera:
         Returns:
             bool: True if intersection occurs, False otherwise.
         """
-        # return (
-        #     self.rect.x < rect.right
-        #     and self.rect.right > rect.x
-        #     and self.rect.y < rect.bottom
-        #     and self.rect.bottom > rect.y
-        # )
         return self.rect.colliderect(rect)
 
-    def transpose(self, rect: pygame.Rect | pygame.FRect) -> pygame.Rect | pygame.FRect:
+    def world_to_screen(
+        self, rect: pygame.Rect | pygame.FRect
+    ) -> pygame.Rect | pygame.FRect:
         """
-        Transpose the given rectangle coordinates relative to the camera.
+        world_to_screen the given rectangle coordinates relative to the camera.
 
         Args:
-            rect (pygame.Rect | pygame.FRect): Rectangle to transpose.
+            rect (pygame.Rect | pygame.FRect): Rectangle to world_to_screen.
 
         Returns:
             pygame.FRect: Transposed rectangle.
         """
-        return pygame.FRect(rect.x - self.rect.left, rect.y - self.rect.top, *rect.size)
-
+        return pygame.FRect(rect[0] - self.rect.left, rect[1] - self.rect.top, rect[2],rect[3])
 
-    def transpose_point(self, point: tuple[float,float] | tuple[int,int]) -> tuple[float,float]:
+    def world_to_screen_point(
+        self, point: tuple[float, float] | tuple[int, int]
+    ) -> tuple[float, float]:
         """
-        Transpose the given 2D point coordinates relative to the camera.
+        world_to_screen the given 2D point coordinates relative to the camera.
 
         Args:
-            point (tuple[float,float] | tuple[int,int]): Point to transpose.
+            point (tuple[float,float] | tuple[int,int]): Point to world_to_screen.
 
         Returns:
             tuple[float,float] : Transposed point.
         """
-        return point[0]-self.rect.x,point[1]-self.rect.y
-
+        return point[0] - self.rect.x, point[1] - self.rect.y
 
-
-    def convert_screen_to_world(self, x, y):
+    def screen_to_world(
+        self, point: tuple[float, float] | tuple[int, int]
+    ) -> tuple[float, float]:
         """
         Convert screen coordinates to world coordinates based on camera settings.
 
         Args:
-            x: X-coordinate in screen space.
-            y: Y-coordinate in screen space.
-
+            point (tuple[float,float] | tuple[int,int]): Point to screen_to_world.
         Returns:
             tuple: Converted world coordinates.
         """
-        return x / self.zoom_factor + self.rect.x, y / self.zoom_factor + self.rect.y
+        return (
+            point[0] / self.zoom_factor + self.rect.x,
+            point[1] / self.zoom_factor + self.rect.y,
+        )
 
     def update(self, dt):
         """
@@ -272,9 +287,9 @@ class Camera:
             dt: Time delta for updating the camera position.
         """
         if self.follow_point_func:
-            amount = ((dt * 60) * self.follow_speed)
-            target = self.follow_point_func()
-            self.set_center(*self.vector_center.lerp(target, amount))
+            self.vector_center.update(*self.rect.center)
+            amount = pygame.math.clamp(self.follow_friction,0,1)
+            self.set_center(*self.vector_center.lerp(self.follow_point_func(), amount))
 
     def draw(self, surface: pygame.Surface):
         """
@@ -289,5 +304,5 @@ class Camera:
             return
 
         # Scale the surface to match the resolution
-        scaled_surface = pygame.transform.scale(self.surface, bf.const.RESOLUTION)
+        scaled_surface = pygame.transform.scale(self.surface, self.target_size)
         surface.blit(scaled_surface, (0, 0), special_flags=self.blit_special_flags)

batFramework/constants.py

@@ -1,59 +1,37 @@
 import pygame
-from enum import Enum
-import sys, os
-
-
-if getattr(sys, "frozen", False):
-    # If the application is run as a bundle, the PyInstaller bootloader
-    # extends the sys module by a flag frozen=True and sets the app
-    # path into variable _MEIPASS'.
-    application_path = sys._MEIPASS
-else:
-    application_path = os.getcwd()
-
-class Colors:
-    LIGHT_CYAN = (179, 229, 252)
-    WASHED_BLUE = (52, 73, 94)
-    RIVER_BLUE = (52, 152, 219)
-    DARK_INDIGO = (40, 53, 147)
-    LIGHT_BLUE = (3, 169, 244)
-    DEEP_BLUE = (41, 121, 255)
-    DARK_BLUE = (44, 62, 80)
-    
-    GREEN = (67, 160, 71)
-    DARK_GREEN = (39, 174, 96)
-    
-    BROWN = (109, 76, 65)
-    DARK_RED = (192, 57, 43)
-    
-    ORANGE = (251, 140, 0)
-    
-    CLOUD_WHITE = (236, 240, 241)
-    SILVER = (189, 195, 199)
-    DARK_GRAY = (66, 66, 66)
-
-    DARK_GB = (27, 42, 9)
-    SHADE_GB = (14, 69, 11)
-    BASE_GB = (73, 107, 34)
-    LIGHT_GB = (154, 158, 63)
-
 
 
 class Constants:
-    SCREEN = None
+    SCREEN: pygame.Surface = None
     RESOLUTION: tuple[int, int] = (1280, 720)
     VSYNC = 0
     FLAGS: int = pygame.SCALED | pygame.RESIZABLE
     FPS: int = 60
     MUSIC_END_EVENT = pygame.event.custom_type()
 
-    BF_INITIALIZED : bool = False
+    DEFAULT_CURSOR = pygame.cursors.Cursor(pygame.SYSTEM_CURSOR_ARROW)
+    DEFAULT_HOVER_CURSOR = pygame.cursors.Cursor(pygame.SYSTEM_CURSOR_ARROW)
+    DEFAULT_CLICK_CURSOR = pygame.cursors.Cursor(pygame.SYSTEM_CURSOR_ARROW)
+
+    BF_INITIALIZED: bool = False
+
     @staticmethod
     def set_resolution(resolution: tuple[int, int]):
         Constants.RESOLUTION = resolution
 
+    @staticmethod
+    def set_default_cursor(cursor: pygame.Cursor):
+        Constants.DEFAULT_CURSOR = cursor
+
+    @staticmethod
+    def set_default_hover_cursor(cursor: pygame.Cursor):
+        Constants.DEFAULT_HOVER_CURSOR = cursor
+
+    @staticmethod
+    def set_default_click_cursor(cursor: pygame.Cursor):
+        Constants.DEFAULT_CLICK_CURSOR = cursor
+
     @staticmethod
     def set_fps_limit(value: int):
         Constants.FPS = value
         print("FPS limit to : ", value)
-

batFramework/cutscene.py

@@ -1,5 +1,6 @@
 import batFramework as bf
 
+
 class CutsceneBlock:
     ...
 
@@ -12,9 +13,9 @@ class CutsceneManager(metaclass=bf.Singleton):
     def __init__(self) -> None:
         self.current_cutscene: Cutscene = None
         self.cutscenes: list[bf.Cutscene] = []
-        self.manager = None
-        
-    def set_manager(self,manager):
+        self.manager: bf.Manager = None
+
+    def set_manager(self, manager):
         self.manager = manager
 
     def get_flag(self, flag):
@@ -37,10 +38,11 @@ class CutsceneManager(metaclass=bf.Singleton):
             self.current_cutscene.play()
         self.manager.set_sharedVar("in_cutscene", True)
 
-    def enable_player_control(self)->None:
-        self.manager.set_sharedVar("player_has_control",True)
-    def disable_player_control(self)->None:
-        self.manager.set_sharedVar("player_has_control",False)
+    def enable_player_control(self) -> None:
+        self.manager.set_sharedVar("player_has_control", True)
+
+    def disable_player_control(self) -> None:
+        self.manager.set_sharedVar("player_has_control", False)
 
     def update(self, dt):
         if not self.current_cutscene is None:
@@ -72,15 +74,15 @@ class Cutscene:
     def init_blocks(self):
         pass
 
-    def add_blocks(self,*blocks:CutsceneBlock):
+    def add_blocks(self, *blocks: CutsceneBlock):
         self.cutscene_blocks.extend(blocks)
 
-    def add_end_blocks(self, *blocks:CutsceneBlock):
+    def add_end_blocks(self, *blocks: CutsceneBlock):
         _ = [block.set_parent_cutscene(self) for block in blocks]
         self.end_blocks.extend(blocks)
 
     def get_scene_at(self, index):
-        return bf.CutsceneManager().manager._scenes[index]
+        return bf.CutsceneManager().manager.scenes[index]
 
     def get_current_scene(self):
         return bf.CutsceneManager().manager.get_current_scene()
@@ -122,6 +124,5 @@ class Cutscene:
                     self.end_blocks = []
             self.cutscene_blocks[self.block_index].start()
 
-
     def has_ended(self):
         return self.ended

batFramework/cutsceneBlocks.py

@@ -1,5 +1,6 @@
 import batFramework as bf
 from .cutscene import Cutscene, CutsceneManager
+from .transition import *
 
 
 # Define the base CutsceneBlock class
@@ -18,7 +19,7 @@ class CutsceneBlock:
         self.started = False
 
     def get_scene_at(self, index):
-        return bf.CutsceneManager().manager._scenes[index]
+        return bf.CutsceneManager().manager.scenes[index]
 
     def set_scene(self, name, index=0):
         return CutsceneManager().manager.set_scene(name, index)
@@ -89,6 +90,7 @@ class ParallelBlock(CutsceneBlock):
     """
     Represents a parallel execution block for multiple Cutscene blocks.
     """
+
     def __init__(self, *blocks) -> None:
         super().__init__()
         # List of blocks to run in parallel
@@ -121,15 +123,16 @@ class SceneTransitionBlock(CutsceneBlock):
     """
 
     # Constructor for SceneTransitionBlock
-    def __init__(self, scene, transition, duration, **kwargs) -> None:
+    def __init__(
+        self, scene, transition: Transition = Fade(0.1), index: int = 0
+    ) -> None:
         super().__init__()
         # Target scene, transition type, duration, and additional keyword arguments
         self.target_scene = scene
         self.transition = transition
-        self.duration = duration
-        self.kwargs = kwargs
+        self.index = index
         # Timer to handle the end of the transition
-        self.timer = bf.Timer(duration=duration, end_callback=self.end)
+        self.timer = bf.Timer(transition.duration, self.end)
 
     # Start the scene transition block
     def start(self):
@@ -137,22 +140,16 @@ class SceneTransitionBlock(CutsceneBlock):
         Start the scene transition block.
         """
         super().start()
-        print(f"transition to {scene}")
-
         # Initiate the scene transition
-        if self.get_current_scene()._name == self.target_scene:
+        if self.get_current_scene().name == self.target_scene:
             self.end()
             return
         CutsceneManager().manager.transition_to_scene(
-            self.target_scene, self.transition, duration=self.duration, **self.kwargs
+            self.target_scene, self.transition, self.index
         )
         # Start the timer to handle the end of the transition
         self.timer.start()
 
-    def end(self):
-        return super().end()
-
-
 
 class DelayBlock(CutsceneBlock):
     def __init__(self, duration) -> None:
@@ -163,8 +160,9 @@ class DelayBlock(CutsceneBlock):
         super().start()
         self.timer.start()
 
+
 class FunctionBlock(CutsceneBlock):
-    def __init__(self,func)->None:
+    def __init__(self, func) -> None:
         self.function = func
 
     def start(self):