batframework 1.0.7__py3-none-any.whl → 1.0.8a2__py3-none-any.whl

batFramework/camera.py

@@ -1,293 +1,123 @@
+import batFramework as bf
 import pygame
 from pygame.math import Vector2
-import math
-import batFramework as bf
 
 
 class Camera:
-
-    def __init__(self, flags=0, size: tuple[int,int] | None = None,convert_alpha:bool=False) -> None:
-        """
-        Initialize the Camera object.
-
-        Args:
-            flags (int): Flags for camera initialization.
-            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.flags: int = flags | (pygame.SRCALPHA if convert_alpha else 0)
+    def __init__(self, flags=0) -> None:
+        self.rect = pygame.FRect(0, 0, *bf.const.RESOLUTION)
+        self.flags: int = flags
+        # self.blit_special_flags : int =pygame.BLEND_PREMULTIPLIED if (flags & pygame.SRCALPHA) 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._clear_color : pygame.Color = pygame.Color(0, 0, 0, 0)
+        self.zoom_factor = 1
         self.cached_surfaces: dict[float, pygame.Surface] = {}
-        
+        self.surface: pygame.Surface = pygame.Surface((0,0))
         self.follow_point_func = None
-        self.follow_speed :float= 0.1 
-        
-        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":
-        """
-        Set the clear color for the camera surface.
-
-        Args:
-            color (pygame.Color | tuple): Color to set as the clear color.
-
-        Returns:
-            Camera: Returns the Camera object.
-        """
-        if not isinstance(color, pygame.Color):
+    def set_clear_color(self, color: pygame.Color|tuple):
+        if not isinstance(color,pygame.Color):
             color = pygame.Color(color)
         self._clear_color = color
-        return self
-
-    def set_max_zoom(self, value: float) -> "Camera":
-        """
-        Set the maximum zoom value for the camera.
-
-        Args:
-            value (float): Maximum zoom value.
 
-        Returns:
-            Camera: Returns the Camera object.
-        """
+    def set_max_zoom(self,value:float):
         self.max_zoom = value
-        return self
-
-    def set_min_zoom(self, value: float) -> "Camera":
-        """
-        Set the minimum zoom value for the camera.
-
-        Args:
-            value (float): Minimum zoom value.
 
-        Returns:
-            Camera: Returns the Camera object.
-        """
+    def set_min_zoom(self,value:float):
         self.min_zoom = value
-        return self
 
-    def clear(self) -> None:
+    def clear(self):
         """
-        Clear the camera surface with the set clear color.
+        Clear the camera surface with the set clear color
+        (default is tranparent)
         """
         self.surface.fill(self._clear_color)
 
-    def get_center(self) -> tuple[float,float]:
-        """
-        Get the center of the camera's view.
-
-        Returns:
-            tuple[float,float]: Returns the center coordinates.
-        """
+    def get_center(self):
         return self.rect.center
 
-    def get_position(self) -> tuple[float,float]:
-        """
-        Get the center of the camera's view.
+    
 
-        Returns:
-            tuple[float,float]: Returns the center coordinates.
+    def move(self, x, y):
         """
-        return self.rect.topleft
-
-    def move_by(self, x : float|int, y:float|int) -> "Camera":
-        """
-        Moves the camera rect by the given coordinates.
-
-        Args:
-            x: X-coordinate to move.
-            y: Y-coordinate to move.
-
-        Returns:
-            Camera: Returns the Camera object.
+        Moves the camera rect by the given coordinates (+=)
         """
-        self.rect.move_ip(x, y)
-        self.vector_center.update(self.rect.center)
-        return self
+        self.rect.topleft += Vector2(x, y)
 
-    def set_position(self, x, y) -> "Camera":
+    def set_position(self, x, y):
         """
-        Set the camera rect top-left position.
-
-        Args:
-            x: X-coordinate to set.
-            y: Y-coordinate to set.
-
-        Returns:
-            Camera: Returns the Camera object.
+        Set the camera rect topleft position
         """
         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):
         """
-        Set the camera rect center position.
-
-        Args:
-            x: X-coordinate for the center.
-            y: Y-coordinate for the center.
-
-        Returns:
-            Camera: Returns the Camera object.
+        Set the camera rect center position
         """
         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_dynamic_point(self, func):
         """
-        Set the following function (returns tuple x y).
-        Camera will center its position to the center of the given coordinates.
-
-        Args:
-            func: Function returning coordinates to follow.
-
-        Returns:
-            Camera: Returns the Camera object.
+        Set the following function (returns tuple x y)
+        (camera will center its position to the center of the given coordinates)
         """
         self.follow_point_func = func
-        self.follow_speed =  follow_speed if func else 0.1
-        return self
-
-    def zoom_by(self, amount: float) -> "Camera":
-        """
-        Zooms the camera by the given amount.
 
-        Args:
-            amount (float): Amount to zoom.
-
-        Returns:
-            Camera: Returns the Camera object.
-        """
+    def zoom_by(self, amount:float):
         self.zoom(self.zoom_factor + amount)
-        return self
-
-    def zoom(self, factor) -> "Camera":
-        """
-        Zooms the camera to the given factor.
-
-        Args:
-            factor: Factor to set for zooming.
 
-        Returns:
-            Camera: Returns the Camera object.
-        """
-        if factor < self.min_zoom or factor > self.max_zoom:
-            return self
-
-        factor = round(factor, 2)
+    def zoom(self, factor):
+        if factor <self.min_zoom:
+            return
+        if factor > self.max_zoom:
+            return
+        factor = round(factor,2)
         self.zoom_factor = factor
-
         if factor not in self.cached_surfaces:
+            # if factor != 1 : print("creating new surface in cache : ",tuple(i * factor for i in const.RESOLUTION), self.flags)
             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))
+            ).convert_alpha()
+            # c = self.surface.get_colorkey() if self.surface else None
+            # if c : self.cached_surfaces[factor].set_colorkey(c)
+            self.cached_surfaces[factor].fill((0, 0, 0, 0))
 
         self.surface = self.cached_surfaces[self.zoom_factor]
         self.rect = self.surface.get_frect(center=self.rect.center)
-        self.clear()
-        return self
+        # if factor != 1 : print(self.cached_surfaces)
 
     def intersects(self, rect: pygame.Rect | pygame.FRect) -> bool:
-        """
-        Check if the camera view intersects with the given rectangle.
+        return (
+            self.rect.x < rect.right
+            and self.rect.right > rect.x
+            and self.rect.y < rect.bottom
+            and self.rect.bottom > rect.y
+        )
 
-        Args:
-            rect (pygame.Rect | pygame.FRect): Rectangle to check intersection with.
-
-        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:
-        """
-        Transpose the given rectangle coordinates relative to the camera.
-
-        Args:
-            rect (pygame.Rect | pygame.FRect): Rectangle to transpose.
-
-        Returns:
-            pygame.FRect: Transposed rectangle.
-        """
-        return pygame.FRect(rect.x - self.rect.left, rect.y - self.rect.top, *rect.size)
-
-
-    def transpose_point(self, point: tuple[float,float] | tuple[int,int]) -> tuple[float,float]:
-        """
-        Transpose the given 2D point coordinates relative to the camera.
-
-        Args:
-            point (tuple[float,float] | tuple[int,int]): Point to transpose.
-
-        Returns:
-            tuple[float,float] : Transposed point.
-        """
-        return point[0]-self.rect.x,point[1]-self.rect.y
-
-
+        x, y = round(rect.x - self.rect.left), round(rect.y - self.rect.top)
+        return pygame.Rect(x, y, *rect.size)
 
     def convert_screen_to_world(self, x, y):
-        """
-        Convert screen coordinates to world coordinates based on camera settings.
-
-        Args:
-            x: X-coordinate in screen space.
-            y: Y-coordinate in screen space.
-
-        Returns:
-            tuple: Converted world coordinates.
-        """
         return x / self.zoom_factor + self.rect.x, y / self.zoom_factor + self.rect.y
 
     def update(self, dt):
-        """
-        Update the camera position based on the follow point function.
-
-        Args:
-            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.rect.center = Vector2(self.rect.center).lerp(target, ((dt * 60) * 0.1))
 
     def draw(self, surface: pygame.Surface):
-        """
-        Draw the camera view onto the provided surface with proper scaling.
-
-        Args:
-            surface (pygame.Surface): Surface to draw the camera view onto.
-        """
+        # pygame.draw.circle(surface,bf.color.ORANGE,self.surface.get_rect().center,4)
         if self.zoom_factor == 1:
             surface.blit(self.surface, (0, 0), special_flags=self.blit_special_flags)
-            # surface.blit(self.surface, (0, 0))
             return
-
-        # Scale the surface to match the resolution
-        scaled_surface = pygame.transform.scale(self.surface, bf.const.RESOLUTION)
-        surface.blit(scaled_surface, (0, 0), special_flags=self.blit_special_flags)
+        # print("From",self.surface,"Target RESOLUTION",const.RESOLUTION,"Destination",surface)
+        surface.blit(
+            pygame.transform.scale(self.surface, bf.const.RESOLUTION),
+            (0, 0),
+            special_flags=self.blit_special_flags,
+        )

batFramework/constants.py

@@ -1,15 +1,52 @@
 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 Constants:
+    SCREEN = None
+    RESOLUTION: tuple[int, int] = (1280,720)
+    VSYNC = 0
+    FLAGS: int = pygame.SCALED | pygame.RESIZABLE
+    FPS: int = 60
+    RESOURCE_PATH = "."
+    
+    @staticmethod
+    def init_screen(resolution:tuple[int,int],flags:int= 0, vsync:int= 0):
+        Constants.RESOLUTION = resolution
+        Constants.FLAGS = flags
+        Constants.VSYNC = vsync
+        Constants.SCREEN = pygame.display.set_mode(Constants.RESOLUTION, Constants.FLAGS,vsync=Constants.VSYNC)
+        print(f"Window : {resolution[0]}x{resolution[1]}px | flags:{flags.bit_count()}, vsync:{pygame.display.is_vsync()}")
+    MUSIC_END_EVENT = pygame.event.custom_type()
+
+    # ------------GUI SPECIFIC
+    DEFAULT_TEXT_SIZE: int = 8
+
+    GUI_SCALE: int = 1
+    # ---------------------
+
+    @staticmethod
+    def set_resolution(resolution : tuple[int,int]):
+        Constants.RESOLUTION = resolution
+
+    @staticmethod
+    def set_resource_path(path: str):
+        print("set resource path :", path)
+        Constants.RESOURCE_PATH = path
+
+    @staticmethod
+    def set_fps_limit(value: int):
+        Constants.FPS = value
+        print("FPS limit to : ", value)
+
+    @staticmethod
+    def set_gui_scale(value: int):
+        Constants.GUI_SCALE = value
+        print("GUI_SCALE to : ", value)
+
+    @staticmethod
+    def set_default_text_size(size:int):
+        Constants.DEFAULT_TEXT_SIZE = size
 
 class Colors:
     LIGHT_CYAN = (179, 229, 252)
@@ -19,15 +56,11 @@ class Colors:
     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)
@@ -37,23 +70,6 @@ class Colors:
     BASE_GB = (73, 107, 34)
     LIGHT_GB = (154, 158, 63)
 
-
-
-class Constants:
-    SCREEN = 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
-    @staticmethod
-    def set_resolution(resolution: tuple[int, int]):
-        Constants.RESOLUTION = resolution
-
-    @staticmethod
-    def set_fps_limit(value: int):
-        Constants.FPS = value
-        print("FPS limit to : ", value)
-
+class Axis(Enum):
+    HORIZONTAL  = 1
+    VERTICAL    = 2

batFramework/cutscene.py

@@ -1,5 +1,6 @@
 import batFramework as bf
 
+
 class CutsceneBlock:
     ...
 
@@ -9,13 +10,10 @@ class Cutscene:
 
 
 class CutsceneManager(metaclass=bf.Singleton):
-    def __init__(self) -> None:
+    def __init__(self, manager) -> None:
         self.current_cutscene: Cutscene = None
-        self.cutscenes: list[bf.Cutscene] = []
-        self.manager = None
-        
-    def set_manager(self,manager):
-        self.manager = manager
+        self.cutscenes : list[bf.Cutscene] = [] 
+        self.manager: bf.Manager = manager
 
     def get_flag(self, flag):
         return None
@@ -24,11 +22,11 @@ class CutsceneManager(metaclass=bf.Singleton):
         if self.current_cutscene:
             self.current_cutscene.process_event(event)
 
-    def queue(self, *cutscenes):
+    def queue(self,*cutscenes):
         self.cutscenes.extend(cutscenes)
         if self.current_cutscene is None:
             self.play(self.cutscenes.pop(0))
-
+            
     def play(self, cutscene: Cutscene):
         if self.current_cutscene is None:
             self.current_cutscene = cutscene
@@ -37,32 +35,25 @@ 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 update(self, dt):
         if not self.current_cutscene is None:
             self.current_cutscene.update(dt)
             # print("cutscene manager update")
             if self.current_cutscene.has_ended():
                 self.current_cutscene.on_exit()
-                self.current_cutscene = None
+                self.current_cutscene =None
                 if self.cutscenes:
                     self.play(self.cutscenes.pop(0))
                 else:
                     self.current_cutscene = None
                     self.manager.set_sharedVar("in_cutscene", False)
 
-
 class Cutscene:
-    def __init__(self) -> None:
-        self.cutscene_blocks = []
+    def __init__(self,*blocks) -> None:
+        self.cutscene_blocks: list[CutsceneBlock] = list(blocks)
         self.block_index = 0
-        self.end_blocks: list[CutsceneBlock] = []
+        self.end_blocks : list[CutsceneBlock] = []
         self.ended = False
-
     def on_enter(self):
         pass
 
@@ -72,26 +63,23 @@ class Cutscene:
     def init_blocks(self):
         pass
 
-    def add_blocks(self,*blocks:CutsceneBlock):
-        self.cutscene_blocks.extend(blocks)
+    def add_end_block(self,block):
+        block.set_parent_cutscene(self)
+        self.end_blocks.append(block)
 
-    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):
+    def get_scene_at(self,index):
         return bf.CutsceneManager().manager._scenes[index]
 
     def get_current_scene(self):
         return bf.CutsceneManager().manager.get_current_scene()
+    
+    def set_scene(self,name,index=0):
+        return bf.CutsceneManager().manager.set_scene(name,index)
 
-    def set_scene(self, name, index=0):
-        return bf.CutsceneManager().manager.set_scene(name, index)
-
-    def get_scene(self, name):
+    def get_scene(self,name):
         return bf.CutsceneManager().manager.get_scene(name)
-
-    def add_block(self, *blocks: CutsceneBlock):
+    
+    def add_block(self, *blocks: list[CutsceneBlock]):
         for block in blocks:
             block.set_parent_cutscene(self)
             self.cutscene_blocks.append(block)
@@ -110,6 +98,7 @@ class Cutscene:
     def update(self, dt):
         if self.ended:
             return
+        # print("cutscene update",self.cutscene_blocks[self.block_index])
         self.cutscene_blocks[self.block_index].update(dt)
         if self.cutscene_blocks[self.block_index].has_ended():
             self.block_index += 1
@@ -122,6 +111,9 @@ class Cutscene:
                     self.end_blocks = []
             self.cutscene_blocks[self.block_index].start()
 
+            # print("NEXT BLOCK")
 
     def has_ended(self):
         return self.ended
+
+

batFramework/cutsceneBlocks.py

@@ -1,5 +1,5 @@
 import batFramework as bf
-from .cutscene import Cutscene, CutsceneManager
+from .cutscene import Cutscene,CutsceneManager
 
 
 # Define the base CutsceneBlock class
@@ -17,18 +17,18 @@ class CutsceneBlock:
         self.ended = False
         self.started = False
 
-    def get_scene_at(self, index):
+    def get_scene_at(self,index):
         return bf.CutsceneManager().manager._scenes[index]
 
-    def set_scene(self, name, index=0):
-        return CutsceneManager().manager.set_scene(name, index)
-
+    def set_scene(self,name,index=0):
+        return CutsceneManager().manager.set_scene(name,index)
+    
     def get_current_scene(self):
         return CutsceneManager().manager.get_current_scene()
-
-    def get_scene(self, name):
+    
+    def get_scene(self,name):
         return CutsceneManager().manager.get_scene(name)
-
+    
     # Set the parent cutscene for this block
     def set_parent_cutscene(self, parent):
         """
@@ -89,13 +89,18 @@ class ParallelBlock(CutsceneBlock):
     """
     Represents a parallel execution block for multiple Cutscene blocks.
     """
+
+    # Constructor for ParallelBlock, taking a variable number of blocks as arguments
     def __init__(self, *blocks) -> None:
         super().__init__()
         # List of blocks to run in parallel
-        self.blocks: list[CutsceneBlock] = list(blocks)
+        self.blocks: list[CutsceneBlock] = blocks
 
     # Start the parallel block (override the base class method)
     def start(self):
+        """
+        Start the parallel execution block.
+        """
         super().start()
         # Start each block in parallel
         for block in self.blocks:
@@ -103,14 +108,32 @@ class ParallelBlock(CutsceneBlock):
 
     # Process an event for each block in parallel
     def process_event(self, event):
+        """
+        Process an event for each block in the parallel execution block.
+
+        Args:
+            event: The event to be processed.
+        """
         _ = [b.process_event(event) for b in self.blocks]
 
     # Update each block in parallel
     def update(self, dt):
+        """
+        Update each block in the parallel execution block.
+
+        Args:
+            dt: Time elapsed since the last update.
+        """
         _ = [b.update(dt) for b in self.blocks]
 
     # Check if all blocks have ended
     def has_ended(self):
+        """
+        Check if all blocks in the parallel execution block have ended.
+
+        Returns:
+            bool: True if all blocks have ended, False otherwise.
+        """
         return all(b.has_ended() for b in self.blocks)
 
 
@@ -129,7 +152,7 @@ class SceneTransitionBlock(CutsceneBlock):
         self.duration = duration
         self.kwargs = kwargs
         # Timer to handle the end of the transition
-        self.timer = bf.Timer(duration=duration, end_callback=self.end)
+        self.timer = bf.Timer(name = "scene_transition_block",duration=duration, end_callback=self.end)
 
     # Start the scene transition block
     def start(self):
@@ -151,23 +174,3 @@ class SceneTransitionBlock(CutsceneBlock):
 
     def end(self):
         return super().end()
-
-
-
-class DelayBlock(CutsceneBlock):
-    def __init__(self, duration) -> None:
-        super().__init__()
-        self.timer = bf.Timer(duration=duration, end_callback=self.end)
-
-    def start(self):
-        super().start()
-        self.timer.start()
-
-class FunctionBlock(CutsceneBlock):
-    def __init__(self,func)->None:
-        self.function = func
-
-    def start(self):
-        super().start()
-        self.function()
-        self.end()