batframework 1.0.8a9__py3-none-any.whl → 1.0.8a10__py3-none-any.whl

batFramework/camera.py

@@ -1,123 +1,313 @@
-import batFramework as bf
 import pygame
 from pygame.math import Vector2
+import batFramework as bf
+from typing import Self
+import math
 
 
 class Camera:
-    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
+    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
+        """
+        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)
-        self.zoom_factor = 1
-        self.cached_surfaces: dict[float, pygame.Surface] = {}
-        self.surface: pygame.Surface = pygame.Surface((0,0))
+
+        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.damping = float("inf")
+        self.dead_zone_radius = 10
+
+        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):
-        if not isinstance(color,pygame.Color):
-            color = pygame.Color(color)
+    def set_clear_color(self, color: pygame.Color | tuple | str) -> Self:
+        """
+        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.
+        """
         self._clear_color = color
+        return self
 
-    def set_max_zoom(self,value:float):
+    def set_max_zoom(self, value: float) -> Self:
+        """
+        Set the maximum zoom value for the camera.
+
+        Args:
+            value (float): Maximum zoom value.
+
+        Returns:
+            Camera: Returns the Camera object.
+        """
         self.max_zoom = value
+        return self
+
+    def set_min_zoom(self, value: float) -> Self:
+        """
+        Set the minimum zoom value for the camera.
+
+        Args:
+            value (float): Minimum zoom value.
 
-    def set_min_zoom(self,value:float):
+        Returns:
+            Camera: Returns the Camera object.
+        """
         self.min_zoom = value
+        return self
 
-    def clear(self):
+    def clear(self) -> None:
         """
-        Clear the camera surface with the set clear color
-        (default is tranparent)
+        Clear the camera surface with the set clear color.
         """
         self.surface.fill(self._clear_color)
 
-    def get_center(self):
+    def get_center(self) -> tuple[float, float]:
+        """
+        Get the center of the camera's view.
+
+        Returns:
+            tuple[float,float]: Returns the center coordinates.
+        """
         return self.rect.center
 
-    
+    def get_position(self) -> tuple[float, float]:
+        """
+        Get the center of the camera's view.
 
-    def move(self, x, y):
+        Returns:
+            tuple[float,float]: Returns the center coordinates.
         """
-        Moves the camera rect by the given coordinates (+=)
+        return self.rect.topleft
+
+    def move_by(self, x: float | int, y: float | int) -> Self:
         """
-        self.rect.topleft += Vector2(x, y)
+        Moves the camera rect by the given coordinates.
+
+        Args:
+            x: X-coordinate to move.
+            y: Y-coordinate to move.
 
-    def set_position(self, x, y):
+        Returns:
+            Camera: Returns the Camera object.
         """
-        Set the camera rect topleft position
+        self.rect.move_ip(x, y)
+        return self
+
+    def set_position(self, x, y) -> Self:
+        """
+        Set the camera rect top-left position.
+
+        Args:
+            x: X-coordinate to set.
+            y: Y-coordinate to set.
+
+        Returns:
+            Camera: Returns the Camera object.
         """
         self.rect.topleft = (x, y)
 
-    def set_center(self, x, y):
+        return self
+
+    def set_center(self, x, y) -> Self:
         """
-        Set the camera rect center position
+        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.
         """
         self.rect.center = (x, y)
+        return self
+
+    def set_follow_point_func(self, func) -> Self:
+        self.follow_point_func = func
+        return self
+
+    def set_follow_speed(self, speed: float) -> Self:
+        self.follow_speed = speed
+        return self
+
+    def set_follow_damping(self, damping: float) -> Self:
+        self.damping = damping
+        return self
+
+    def set_dead_zone_radius(self, radius: float) -> Self:
+        self.dead_zone_radius = radius
+        return self
 
-    def set_follow_dynamic_point(self, func):
+    def zoom_by(self, amount: float) -> Self:
         """
-        Set the following function (returns tuple x y)
-        (camera will center its position to the center of the given coordinates)
+        Zooms the camera by the given amount.
+
+        Args:
+            amount (float): Amount to zoom.
+
+        Returns:
+            Camera: Returns the Camera object.
         """
-        self.follow_point_func = func
+        self.zoom(max(self.min_zoom, min(self.max_zoom, self.zoom_factor + amount)))
+        return self
 
-    def zoom_by(self, amount:float):
-        self.zoom(self.zoom_factor + amount)
+    def zoom(self, factor: float) -> Self:
+        """
+        Zooms the camera to the given factor.
 
-    def zoom(self, factor):
-        if factor <self.min_zoom:
-            return
-        if factor > self.max_zoom:
-            return
-        factor = round(factor,2)
+        Args:
+            factor: Factor to set for zooming.
+
+        Returns:
+            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:
-            # 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
-            ).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]
+        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)
-        # if factor != 1 : print(self.cached_surfaces)
+        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:
-        return (
-            self.rect.x < rect.right
-            and self.rect.right > rect.x
-            and self.rect.y < rect.bottom
-            and self.rect.bottom > rect.y
+        """
+        Check if the camera view intersects with the given rectangle.
+
+        Args:
+            rect (pygame.Rect | pygame.FRect): Rectangle to check intersection with.
+
+        Returns:
+            bool: True if intersection occurs, False otherwise.
+        """
+        return self.rect.colliderect(rect)
+
+    def world_to_screen(
+        self, rect: pygame.Rect | pygame.FRect
+    ) -> pygame.Rect | pygame.FRect:
+        """
+        world_to_screen the given rectangle coordinates relative to the camera.
+
+        Args:
+            rect (pygame.Rect | pygame.FRect): Rectangle to world_to_screen.
+
+        Returns:
+            pygame.FRect: Transposed rectangle.
+        """
+        return pygame.FRect(
+            rect[0] - self.rect.left, rect[1] - self.rect.top, rect[2], rect[3]
         )
 
+    def world_to_screen_point(
+        self, point: tuple[float, float] | tuple[int, int]
+    ) -> tuple[float, float]:
+        """
+        world_to_screen the given 2D point coordinates relative to the camera.
+
+        Args:
+            point (tuple[float,float] | tuple[int,int]): Point to world_to_screen.
 
-    def transpose(self, rect: pygame.Rect | pygame.FRect) -> pygame.Rect | pygame.FRect:
-        x, y = round(rect.x - self.rect.left), round(rect.y - self.rect.top)
-        return pygame.Rect(x, y, *rect.size)
+        Returns:
+            tuple[float,float] : Transposed point.
+        """
+        return point[0] - self.rect.x, point[1] - self.rect.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.
 
-    def convert_screen_to_world(self, x, y):
-        return x / self.zoom_factor + self.rect.x, y / self.zoom_factor + self.rect.y
+        Args:
+            point (tuple[float,float] | tuple[int,int]): Point to screen_to_world.
+        Returns:
+            tuple: Converted world coordinates.
+        """
+        return (
+            point[0] / self.zoom_factor + self.rect.x,
+            point[1] / self.zoom_factor + self.rect.y,
+        )
 
     def update(self, dt):
-        if self.follow_point_func:
-            target = self.follow_point_func()
-            self.rect.center = Vector2(self.rect.center).lerp(target, ((dt * 60) * 0.1))
+        if not self.follow_point_func or not (math.isfinite(dt) and dt > 0):
+            return
+
+        target = Vector2(self.follow_point_func())
+        self.vector_center.update(self.rect.center)
+
+        if self.damping == float("inf"):
+            self.vector_center = target
+        elif math.isfinite(self.damping) and self.damping > 0:
+            damping_factor = 1 - math.exp(-self.damping * dt)
+            if not math.isnan(damping_factor):
+                self.vector_center += (target - self.vector_center) * damping_factor
+
+        self.rect.center = self.vector_center
 
     def draw(self, surface: pygame.Surface):
-        # pygame.draw.circle(surface,bf.color.ORANGE,self.surface.get_rect().center,4)
+        """
+        Draw the camera view onto the provided surface with proper scaling.
+
+        Args:
+            surface (pygame.Surface): Surface to draw the camera view onto.
+        """
         if self.zoom_factor == 1:
             surface.blit(self.surface, (0, 0), special_flags=self.blit_special_flags)
+            # surface.blit(self.surface, (0, 0))
             return
-        # 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,
-        )
+
+        # Scale the surface to match the resolution
+        scaled_surface = pygame.transform.scale(self.surface, self.target_size)
+        surface.blit(scaled_surface, (0, 0), special_flags=self.blit_special_flags)

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

@@ -1,75 +1,37 @@
 import pygame
-from enum import Enum
 
 
 class Constants:
-    SCREEN = None
-    RESOLUTION: tuple[int, int] = (1280,720)
+    SCREEN: pygame.Surface = 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
+    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)
 
-    GUI_SCALE: int = 1
-    # ---------------------
+    BF_INITIALIZED: bool = False
 
     @staticmethod
-    def set_resolution(resolution : tuple[int,int]):
+    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
+    def set_default_cursor(cursor: pygame.Cursor):
+        Constants.DEFAULT_CURSOR = cursor
 
     @staticmethod
-    def set_fps_limit(value: int):
-        Constants.FPS = value
-        print("FPS limit to : ", value)
+    def set_default_hover_cursor(cursor: pygame.Cursor):
+        Constants.DEFAULT_HOVER_CURSOR = cursor
 
     @staticmethod
-    def set_gui_scale(value: int):
-        Constants.GUI_SCALE = value
-        print("GUI_SCALE to : ", value)
+    def set_default_click_cursor(cursor: pygame.Cursor):
+        Constants.DEFAULT_CLICK_CURSOR = cursor
 
     @staticmethod
-    def set_default_text_size(size:int):
-        Constants.DEFAULT_TEXT_SIZE = size
-
-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 Axis(Enum):
-    HORIZONTAL  = 1
-    VERTICAL    = 2
+    def set_fps_limit(value: int):
+        Constants.FPS = value
+        print("FPS limit to : ", value)

batFramework/cutscene.py

@@ -1,19 +1,23 @@
 import batFramework as bf
+from typing import TYPE_CHECKING
 
+class CutsceneBlock: ...
 
-class CutsceneBlock:
-    ...
+if TYPE_CHECKING:
+    from .cutsceneBlocks import CutsceneBlock
 
 
-class Cutscene:
-    ...
+class Cutscene: ...
 
 
 class CutsceneManager(metaclass=bf.Singleton):
-    def __init__(self, manager) -> None:
+    def __init__(self) -> None:
         self.current_cutscene: Cutscene = None
-        self.cutscenes : list[bf.Cutscene] = [] 
-        self.manager: bf.Manager = manager
+        self.cutscenes: list[bf.Cutscene] = []
+        self.manager: bf.Manager = None
+
+    def set_manager(self, manager):
+        self.manager = manager
 
     def get_flag(self, flag):
         return None
@@ -22,11 +26,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
@@ -35,25 +39,33 @@ 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,*blocks) -> None:
-        self.cutscene_blocks: list[CutsceneBlock] = list(blocks)
+    def __init__(self) -> None:
+        self.cutscene_blocks : list[CutsceneBlock] = []
         self.block_index = 0
-        self.end_blocks : list[CutsceneBlock] = []
+        self.end_blocks: list[CutsceneBlock] = []
         self.ended = False
+
     def on_enter(self):
         pass
 
@@ -63,23 +75,26 @@ class Cutscene:
     def init_blocks(self):
         pass
 
-    def add_end_block(self,block):
-        block.set_parent_cutscene(self)
-        self.end_blocks.append(block)
+    def add_blocks(self, *blocks: CutsceneBlock):
+        self.cutscene_blocks.extend(blocks)
 
-    def get_scene_at(self,index):
-        return bf.CutsceneManager().manager._scenes[index]
+    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]
 
     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 get_scene(self,name):
+    def set_scene(self, name, index=0):
+        return bf.CutsceneManager().manager.set_scene(name, index)
+
+    def get_scene(self, name):
         return bf.CutsceneManager().manager.get_scene(name)
-    
-    def add_block(self, *blocks: list[CutsceneBlock]):
+
+    def add_block(self, *blocks: CutsceneBlock):
         for block in blocks:
             block.set_parent_cutscene(self)
             self.cutscene_blocks.append(block)
@@ -98,7 +113,6 @@ 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
@@ -111,9 +125,5 @@ class Cutscene:
                     self.end_blocks = []
             self.cutscene_blocks[self.block_index].start()
 
-            # print("NEXT BLOCK")
-
     def has_ended(self):
         return self.ended
-
-