batframework 1.0.8a1__py3-none-any.whl → 1.0.8a3__py3-none-any.whl

batFramework/action.py

@@ -1,10 +1,9 @@
-from typing import Any,Self
+from typing import Any, Self
 from enum import Enum
 import pygame
 from .enums import actionType
 
 
-
 class Action:
     def __init__(self, name: str) -> None:
         """
@@ -16,7 +15,7 @@ class Action:
         self.name: str = name
         self.active: bool = False
         self.data: dict = {}
-        self.consume_event : bool = False
+        self.consume_event: bool = False
         self._type: actionType = actionType.INSTANTANEOUS
         self._key_control: set = set()
         self._mouse_control: set = set()
@@ -46,16 +45,14 @@ class Action:
         self.active = value
         # self._holding = set()
 
-
-    def add_event_control(self,*events)->Self:
+    def add_event_control(self, *events) -> Self:
         self._event_control.update(events)
         return self
 
-    def remove_event_control(self,*events)->Self:
+    def remove_event_control(self, *events) -> Self:
         self._event_control = self._event_control - events
         return self
 
-
     def add_key_control(self, *keys) -> Self:
         """
         Add key controls to the action.
@@ -89,7 +86,7 @@ class Action:
         self.add_key_control(new_key)
         return self
 
-    def add_mouse_control(self, *mouse_buttons: int) -> Self:
+    def add_mouse_control(self, *mouse: int) -> Self:
         """
         Add mouse control to the action.
 
@@ -99,7 +96,18 @@ class Action:
         Returns:
             Action: The updated Action object for method chaining.
         """
-        self._mouse_control.update(mouse_buttons)
+        self._mouse_control.update(mouse)
+        return self
+
+    def remove_mouse_control(self, *mouse: int) -> Self:
+        self._mouse_control = self._mouse_control - set(mouse)
+        return self
+
+    def replace_mouse_control(self, mouse, new_mouse) -> Self:
+        if not mouse in self._mouse_control:
+            return self
+        self.remove_mouse_control(mouse)
+        self.add_mouse_control(new_mouse)
         return self
 
     def set_continuous(self) -> Self:
@@ -183,7 +191,9 @@ class Action:
         if event.type == pygame.KEYDOWN and event.key in self._key_control:
             self._activate_action(event.key)
 
-        elif event.type == pygame.MOUSEBUTTONDOWN and event.button in self._mouse_control:
+        elif (
+            event.type == pygame.MOUSEBUTTONDOWN and event.button in self._mouse_control
+        ):
             self._activate_action(event.button)
 
         elif event.type == pygame.MOUSEMOTION and event.type in self._mouse_control:
@@ -194,7 +204,8 @@ class Action:
             self.data = event.dict
         else:
             return
-        if self.consume_event : event.consumed = True
+        if self.consume_event:
+            event.consumed = True
 
     def _activate_action(self, control):
         self.active = True
@@ -212,7 +223,10 @@ class Action:
         if self._type == actionType.HOLDING:
             if event.type == pygame.KEYUP and event.key in self._key_control:
                 self._deactivate_action(event.key)
-            elif event.type == pygame.MOUSEBUTTONUP and event.button in self._mouse_control:
+            elif (
+                event.type == pygame.MOUSEBUTTONUP
+                and event.button in self._mouse_control
+            ):
                 self._deactivate_action(event.button)
             elif event.type == pygame.MOUSEMOTION and event.type in self._mouse_control:
                 self._deactivate_action(event.type)
@@ -221,7 +235,8 @@ class Action:
             else:
                 event.consumed = False
 
-        if self.consume_event: event.consumed = True
+        if self.consume_event:
+            event.consumed = True
 
     def _deactivate_action(self, control) -> bool:
         if control in self._holding:
@@ -237,7 +252,8 @@ class Action:
             event (pygame.event.Event): The pygame event to process.
         """
 
-        if event.consumed : return
+        if event.consumed:
+            return
         if not self.active:
             self.process_activate(event)
         else:

batFramework/actionContainer.py

@@ -34,11 +34,13 @@ class ActionContainer:
         )
 
     def process_event(self, event):
-        if event.consumed : return
+        if event.consumed:
+            return
         for action in self._actions.values():
             action.process_event(event)
-            if event.consumed == True:break
-             
+            if event.consumed == True:
+                break
+
     def reset(self):
         for action in self._actions.values():
             action.reset()

batFramework/audioManager.py

@@ -24,7 +24,6 @@ class AudioManager(metaclass=bf.Singleton):
     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

batFramework/camera.py

@@ -2,6 +2,7 @@ import pygame
 from pygame.math import Vector2
 import batFramework as bf
 from typing import Self
+import math
 
 
 class Camera:
@@ -32,7 +33,8 @@ class Camera:
             self._clear_color = pygame.Color(0, 0, 0)
 
         self.follow_point_func = None
-        self.follow_friction: float = 0.5
+        self.damping = float("inf")
+        self.dead_zone_radius = 10
 
         self.zoom_factor = 1
         self.max_zoom = 2
@@ -145,23 +147,20 @@ class Camera:
         self.rect.center = (x, y)
         return self
 
-    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.
+    def set_follow_point_func(self, func) -> Self:
+        self.follow_point_func = func
+        return self
 
-        Args:
-            func: Function returning coordinates to follow.
+    def set_follow_speed(self, speed: float) -> Self:
+        self.follow_speed = speed
+        return self
 
-        Returns:
-            Camera: Returns the Camera object.
-        """
-        self.follow_point_func = func
-        self.follow_speed = follow_speed if func else 0.1
+    def set_follow_damping(self, damping: float) -> Self:
+        self.damping = damping
         return self
 
-    def set_follow_friction(self,friction:float)->Self:
-        self.follow_friction = friction
+    def set_dead_zone_radius(self, radius: float) -> Self:
+        self.dead_zone_radius = radius
         return self
 
     def zoom_by(self, amount: float) -> Self:
@@ -247,7 +246,9 @@ class Camera:
         Returns:
             pygame.FRect: Transposed rectangle.
         """
-        return pygame.FRect(rect[0] - self.rect.left, rect[1] - self.rect.top, rect[2],rect[3])
+        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]
@@ -280,16 +281,20 @@ class Camera:
         )
 
     def update(self, dt):
-        """
-        Update the camera position based on the follow point function.
+        if not self.follow_point_func or not (math.isfinite(dt) and dt > 0):
+            return
 
-        Args:
-            dt: Time delta for updating the camera position.
-        """
-        if self.follow_point_func:
-            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))
+        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):
         """

batFramework/cutscene.py

@@ -1,12 +1,10 @@
 import batFramework as bf
 
 
-class CutsceneBlock:
-    ...
+class CutsceneBlock: ...
 
 
-class Cutscene:
-    ...
+class Cutscene: ...
 
 
 class CutsceneManager(metaclass=bf.Singleton):

batFramework/entity.py

@@ -3,10 +3,12 @@ import pygame
 import batFramework as bf
 from .object import Object
 
+
 class Entity(Object):
     """
     Basic entity class
     """
+
     def __init__(
         self,
         size: None | tuple[int, int] = None,
@@ -30,7 +32,7 @@ class Entity(Object):
         self.surface.set_alpha(min(max(0, alpha), 255))
         return self
 
-    def get_alpha(self)->int:
+    def get_alpha(self) -> int:
         return self.surface.get_alpha()
 
     def set_surface_flags(self, surface_flags: int) -> Self:
@@ -45,6 +47,10 @@ class Entity(Object):
         self.blit_flags = blit_flags
         return self
 
+    def get_debug_outlines(self):
+        if self.visible:
+            yield (self.rect, self.debug_color)
+
     def set_render_order(self, render_order: int) -> Self:
         self.render_order = render_order
         if self.parent_scene:
@@ -59,7 +65,8 @@ class Entity(Object):
         """
         Draw the entity onto the camera surface
         """
-        if not self.visible or not camera.rect.colliderect(self.rect): return
+        if not self.visible or not camera.rect.colliderect(self.rect):
+            return
         camera.surface.blit(
             self.surface,
             camera.world_to_screen(self.rect),

batFramework/enums.py

@@ -45,6 +45,7 @@ class color:
     LIGHT_GB = (73, 107, 34)
     LIGHTER_GB = (154, 158, 63)
 
+
 class easing(Enum):
     LINEAR = (0, 0, 1, 1)
     EASE_IN = (0.95, 0, 1, 0.55)
@@ -55,15 +56,19 @@ class easing(Enum):
     def __init__(self, *control_points):
         self.control_points = control_points
 
+
 class axis(Enum):
     HORIZONTAL = "horizontal"
     VERTICAL = "vertical"
 
+
 class spacing(Enum):
     MIN = "min"
     HALF = "half"
     MAX = "max"
     MANUAL = "manual"
+
+
 class alignment(Enum):
     LEFT = "left"
     RIGHT = "right"
@@ -77,21 +82,25 @@ class alignment(Enum):
     BOTTOMLEFT = "bottomleft"
     BOTTOMRIGHT = "bottomright"
 
+
 class direction(Enum):
     LEFT = 0
     UP = 1
     RIGHT = 2
-    DOWN = 3 
+    DOWN = 3
+
 
 class drawMode(Enum):
     SOLID = 0
     TEXTURED = 1
 
+
 class debugMode(Enum):
     HIDDEN = 0
     DEBUGGER = 1
     OUTLINES = 2
 
+
 class actionType(Enum):
     INSTANTANEOUS = 0
     CONTINUOUS = 1
@@ -101,4 +110,4 @@ class actionType(Enum):
 class textMode(Enum):
     ALPHABETICAL = 0
     NUMERICAL = 1
-    ALPHANUMERIC = 3 
+    ALPHANUMERIC = 3

batFramework/fontManager.py

@@ -15,7 +15,7 @@ class FontManager(metaclass=Singleton):
         self.DEFAULT_ANTIALIAS = False
         self.FONTS = {}
 
-    def set_antialias(self,value:bool):
+    def set_antialias(self, value: bool):
         self.DEFAULT_ANTIALIAS = value
 
     def set_default_text_size(self, size: int):

batFramework/gui/__init__.py

@@ -1,5 +1,7 @@
 from .constraints import *
 from .widget import Widget
+from .styleManager import StyleManager
+from .style import Style
 from .image import Image
 from .interactiveWidget import InteractiveWidget
 from .draggableWidget import DraggableWidget
@@ -16,5 +18,5 @@ from .layout import *
 from .container import Container
 from .indicator import *
 from .toggle import Toggle
-from .radioButton import RadioButton,RadioVariable
+from .radioButton import RadioButton, RadioVariable
 from .slider import Slider

batFramework/gui/button.py

@@ -7,6 +7,9 @@ from math import ceil
 
 
 class Button(Label, ClickableWidget):
-    def __init__(self, text: str, callback: None | Callable = None) -> None:
+    def __init__(self, text: str = "", callback: None | Callable = None) -> None:
         super().__init__(text=text)
-        self.set_callback(callback)
+        self.set_callback(callback)
+
+    def __str__(self) -> str:
+        return f"Button({self.text})"

batFramework/gui/clickableWidget.py

@@ -7,10 +7,10 @@ import pygame
 from math import ceil
 
 
-class ClickableWidget(Shape,InteractiveWidget):
+class ClickableWidget(Shape, InteractiveWidget):
     _cache: dict = {}
 
-    def __init__(self,callback: None | Callable = None,*args,**kwargs) -> None:
+    def __init__(self, callback: None | Callable = None, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
         self.callback = callback
         self.is_pressed: bool = False
@@ -21,29 +21,32 @@ class ClickableWidget(Shape,InteractiveWidget):
         self.click_up_sound = None
         self.get_focus_sound = None
         self.lose_focus_sound = None
-        self.pressed_relief : int = 1
-        self.unpressed_relief : int = 2
-        self.silent_focus : bool = False
+        self.pressed_relief: int = 1
+        self.unpressed_relief: int = 2
+        self.silent_focus: bool = False
         self.set_debug_color("cyan")
         self.set_relief(self.unpressed_relief)
 
-    def set_unpressed_relief(self,relief:int=0)->Self:
-        if relief == self.unpressed_relief : return self
-        self.unpressed_relief = relief 
+    def set_unpressed_relief(self, relief: int = 0) -> Self:
+        if relief == self.unpressed_relief:
+            return self
+        self.unpressed_relief = relief
         self.dirty_shape = True
-        if not self.is_pressed : self.set_relief(relief)
+        if not self.is_pressed:
+            self.set_relief(relief)
         return self
 
-    def set_silent_focus(self,value:bool)->Self:
+    def set_silent_focus(self, value: bool) -> Self:
         self.silent_focus = value
         return self
 
-
-    def set_pressed_relief(self,relief:int=0)->Self:
-        if relief == self.pressed_relief : return self
-        self.pressed_relief = relief 
+    def set_pressed_relief(self, relief: int = 0) -> Self:
+        if relief == self.pressed_relief:
+            return self
+        self.pressed_relief = relief
         self.dirty_shape = True
-        if self.is_pressed : self.set_relief(relief)
+        if self.is_pressed:
+            self.set_relief(relief)
 
         return self
 
@@ -72,13 +75,15 @@ class ClickableWidget(Shape,InteractiveWidget):
         return self
 
     def get_surface_filter(self) -> pygame.Surface | None:
-        size = int(self.rect.w),int(self.rect.h)
+        size = int(self.rect.w), int(self.rect.h)
         surface_filter = ClickableWidget._cache.get((size, *self.border_radius), None)
         if surface_filter is None:
             # Create a mask from the original surface
             mask = pygame.mask.from_surface(self.surface, threshold=0)
-            
-            silhouette_surface = mask.to_surface(setcolor=(30, 30, 30), unsetcolor=(0,0,0))
+
+            silhouette_surface = mask.to_surface(
+                setcolor=(30, 30, 30), unsetcolor=(0, 0, 0)
+            )
 
             ClickableWidget._cache[(size, *self.border_radius)] = silhouette_surface
 
@@ -86,7 +91,7 @@ class ClickableWidget(Shape,InteractiveWidget):
 
         return surface_filter
 
-    def allow_focus_to_self(self)->bool:
+    def allow_focus_to_self(self) -> bool:
         return True
 
     def enable(self) -> Self:
@@ -111,7 +116,7 @@ class ClickableWidget(Shape,InteractiveWidget):
         if self.get_focus_sound and not self.silent_focus:
             if self.parent_scene and self.parent_scene.visible:
                 bf.AudioManager().play_sound(self.get_focus_sound)
-        if self.silent_focus : 
+        if self.silent_focus:
             self.silent_focus = False
 
     def on_lose_focus(self):
@@ -119,7 +124,7 @@ class ClickableWidget(Shape,InteractiveWidget):
         if self.lose_focus_sound and not self.silent_focus:
             if self.parent_scene and self.parent_scene.visible:
                 bf.AudioManager().play_sound(self.lose_focus_sound)
-        if self.silent_focus : 
+        if self.silent_focus:
             self.silent_focus = False
 
     def __str__(self) -> str:
@@ -132,7 +137,7 @@ class ClickableWidget(Shape,InteractiveWidget):
             self.callback()
 
     def do_on_click_down(self, button) -> None:
-        if self.enabled and button == 1 :
+        if self.enabled and button == 1:
             if not self.get_focus():
                 return
             self.is_pressed = True
@@ -152,15 +157,15 @@ class ClickableWidget(Shape,InteractiveWidget):
         if not self.enabled:
             return
         super().on_enter()
-        self.dirty_surface  = True
+        self.dirty_surface = True
         pygame.mouse.set_cursor(self.hover_cursor)
 
     def on_exit(self) -> None:
         super().on_exit()
         if self.is_pressed:
             self.set_relief(self.unpressed_relief)
-        self.is_pressed    = False
-        self.dirty_surface  = True
+        self.is_pressed = False
+        self.dirty_surface = True
 
         pygame.mouse.set_cursor(bf.const.DEFAULT_CURSOR)
 
@@ -188,15 +193,23 @@ class ClickableWidget(Shape,InteractiveWidget):
             self.get_surface_filter(), (0, 0), special_flags=pygame.BLEND_RGB_ADD
         )
 
-    def get_padded_rect(self)->pygame.FRect:
+    def get_padded_rect(self) -> pygame.FRect:
         return pygame.FRect(
-            self.rect.x + self.padding[0], self.rect.y + self.padding[1] + (self.unpressed_relief - self.pressed_relief if  self.is_pressed else 0),
+            self.rect.x + self.padding[0],
+            self.rect.y
+            + self.padding[1]
+            + (self.unpressed_relief - self.pressed_relief if self.is_pressed else 0),
             self.rect.w - self.padding[2] - self.padding[0],
-            self.rect.h - self.unpressed_relief - self.padding[1] - self.padding[3] #
+            self.rect.h - self.unpressed_relief - self.padding[1] - self.padding[3],  #
         )
 
     def _get_elevated_rect(self) -> pygame.FRect:
-        return pygame.FRect(0,  self.unpressed_relief - self.pressed_relief if  self.is_pressed else 0 , self.rect.w, self.rect.h - self.unpressed_relief)
+        return pygame.FRect(
+            0,
+            self.unpressed_relief - self.pressed_relief if self.is_pressed else 0,
+            self.rect.w,
+            self.rect.h - self.unpressed_relief,
+        )
 
     def paint(self) -> None:
         super().paint()