batframework 1.0.9a11__py3-none-any.whl → 1.0.9a13__py3-none-any.whl

batFramework/cutsceneManager.py

@@ -1,34 +1,34 @@
-import batFramework as bf
-from typing import TYPE_CHECKING,Self
-import pygame
-# if TYPE_CHECKING:
-from .cutscene import Cutscene
-
-
-class CutsceneManager(metaclass=bf.Singleton):
-    def __init__(self) -> None:
-        self.current_cutscene: Cutscene = None
-        self.manager: bf.Manager = None
-        self.is_playing : bool = False
-    def set_manager(self, manager):
-        self.manager = manager
-
-    def process_event(self, event):
-        if self.current_cutscene is not None:
-            self.current_cutscene.process_event(event)
-            if event.type in bf.enums.playerInput:
-                event.consumed = True
-
-    def play(self,cutscene:Cutscene):
-        if self.current_cutscene is not None:return
-        
-        self.current_cutscene = cutscene
-        cutscene.start()
-        self.is_playing = True
-        
-    def update(self,dt):
-        if self.current_cutscene:
-            self.current_cutscene.update(dt)
-            if self.current_cutscene.is_over:
-                self.current_cutscene = None
-                self.is_playing = False
+import batFramework as bf
+from typing import TYPE_CHECKING,Self
+import pygame
+# if TYPE_CHECKING:
+from .cutscene import Cutscene
+
+
+class CutsceneManager(metaclass=bf.Singleton):
+    def __init__(self) -> None:
+        self.current_cutscene: Cutscene = None
+        self.manager: bf.Manager = None
+        self.is_playing : bool = False
+    def set_manager(self, manager):
+        self.manager = manager
+
+    def process_event(self, event):
+        if self.current_cutscene is not None:
+            self.current_cutscene.process_event(event)
+            if event.type in bf.enums.playerInput:
+                event.consumed = True
+
+    def play(self,cutscene:Cutscene):
+        if self.current_cutscene is not None:return
+        
+        self.current_cutscene = cutscene
+        cutscene.start()
+        self.is_playing = True
+        
+    def update(self,dt):
+        if self.current_cutscene:
+            self.current_cutscene.update(dt)
+            if self.current_cutscene.is_over:
+                self.current_cutscene = None
+                self.is_playing = False

batFramework/drawable.py

@@ -1,77 +1,107 @@
-from typing import Any, Self
-import pygame
-import batFramework as bf
-from .entity import Entity
-
-
-class Drawable(Entity):
-    """
-    Basic entity class
-    """
-
-    def __init__(
-        self,
-        size: None | tuple[int|float] = None,
-        surface_flags: int = 0,
-        convert_alpha: bool = False,
-        *args,
-        **kwargs,
-    ) -> None:
-        super().__init__()
-        self.visible: bool = True
-        self.render_order: int = 0
-        if size is not None:
-            self.rect.size = size
-        self.convert_alpha: bool = convert_alpha
-        self.surface_flags: int = surface_flags
-        self.blit_flags: int = 0
-        self.drawn_by_group : bool = False # flag for render group  
-        self.surface: pygame.Surface = pygame.Surface(self.rect.size, surface_flags)
-        if convert_alpha:
-            self.surface = self.surface.convert_alpha()
-            self.surface.fill((0, 0, 0, 0))
-
-    def set_alpha(self, alpha: int) -> Self:
-        self.surface.set_alpha(min(max(0, alpha), 255))
-        return self
-
-    def get_alpha(self) -> int:
-        return self.surface.get_alpha()
-
-    def set_surface_flags(self, surface_flags: int) -> Self:
-        self.surface_flags = surface_flags
-        return self
-
-    def set_convert_alpha(self, value: bool) -> Self:
-        self.convert_alpha = value
-        return self
-
-    def set_blit_flags(self, blit_flags: int) -> Self:
-        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_layer:
-            self.parent_layer.update_draw_order()
-        return self
-
-    def set_visible(self, value: bool) -> Self:
-        self.visible = value
-        return self
-
-    def draw(self, camera: bf.Camera) -> None:
-        """
-        Draw the entity onto the camera surface
-        """
-        if not self.visible or self.drawn_by_group or not camera.rect.colliderect(self.rect) or self.surface.get_alpha() == 0:
-            return
-        camera.surface.blit(
-            self.surface,
-            camera.world_to_screen(self.rect),
-            special_flags=self.blit_flags,
-        )
+from typing import Any, Self
+import pygame
+import batFramework as bf
+from .entity import Entity
+
+
+class Drawable(Entity):
+    """
+    Basic entity class
+    """
+
+    def __init__(
+        self,
+        size: None | tuple[int|float] = None,
+        surface_flags: int = 0,
+        convert_alpha: bool = False,
+        *args,
+        **kwargs,
+    ) -> None:
+        super().__init__()
+        self.visible: bool = True
+        self.render_order: int = 0
+        if size is not None:
+            self.rect.size = size
+        self.convert_alpha: bool = convert_alpha
+        self.surface_flags: int = surface_flags
+        self.blit_flags: int = 0
+        self.drawn_by_group : bool = False # flag for render group  
+        self.surface: pygame.Surface = pygame.Surface(self.rect.size, surface_flags)
+        if convert_alpha:
+            self.surface = self.surface.convert_alpha()
+            self.surface.fill((0, 0, 0, 0))
+
+    def set_alpha(self, alpha: int) -> Self:
+        self.surface.set_alpha(min(max(0, alpha), 255))
+        return self
+
+    def get_alpha(self) -> int:
+        return self.surface.get_alpha()
+
+    def set_surface_flags(self, surface_flags: int) -> Self:
+        self.surface_flags = surface_flags
+        return self
+
+    def set_convert_alpha(self, value: bool) -> Self:
+        self.convert_alpha = value
+        return self
+
+    def set_blit_flags(self, blit_flags: int) -> Self:
+        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_layer:
+            self.parent_layer.update_draw_order()
+        return self
+
+    def set_visible(self, value: bool) -> Self:
+        self.visible = value
+        return self
+
+    def get_mask(self)->pygame.Mask:
+        return pygame.mask.from_surface(self.surface)
+
+    def mask_collide_point(self,point)->bool:
+        if not self.rect.collidepoint(point):
+            return False
+        mask = pygame.mask.from_surface(self.surface)
+        x = point[0]-  self.rect.x
+        y = point[1] - self.rect.y
+        return mask.get_at((x,y))==1
+
+
+
+
+    def set_size(self, size: tuple[float, float]) -> Self:
+        """
+            Will erase surface data and create new empty surface
+        """
+        if size == self.rect.size:
+            return self
+        self.rect.size = size
+        self.surface = pygame.Surface(
+            (int(self.rect.w), int(self.rect.h)), self.surface_flags
+        )
+        if self.convert_alpha:
+            self.surface = self.surface.convert_alpha()
+        self.surface.fill((0, 0, 0, 0 if self.convert_alpha else 255))
+
+        return self
+
+    def draw(self, camera: bf.Camera) -> None:
+        """
+        Draw the entity onto the camera surface
+        """
+        if not self.visible or self.drawn_by_group or not camera.world_rect.colliderect(self.rect) or self.surface.get_alpha() == 0:
+            return
+        camera.surface.blit(
+            self.surface,
+            camera.world_to_screen(self.rect),
+            special_flags=self.blit_flags,
+        )

batFramework/dynamicEntity.py

@@ -1,30 +1,30 @@
-import pygame
-import batFramework as bf
-from typing import Self
-
-
-class DynamicEntity(bf.Entity):
-    def __init__(
-        self,
-        *args,**kwargs
-    ) -> None:
-        super().__init__(*args,**kwargs)
-        self.velocity = pygame.math.Vector2(0, 0)
-        self.ignore_collisions : bool = False
-
-    def on_collideX(self, collider: "DynamicEntity"):
-        """
-        Return true if collision
-        """
-        return False
-
-    def on_collideY(self, collider: "DynamicEntity"):
-        """
-        Return true if collision
-        """
-        return False
-
-    def move_by_velocity(self, dt) -> None:
-        self.set_position(
-            self.rect.x + self.velocity.x * dt, self.rect.y + self.velocity.y * dt
-        )
+import pygame
+import batFramework as bf
+from typing import Self
+
+
+class DynamicEntity(bf.Entity):
+    def __init__(
+        self,
+        *args,**kwargs
+    ) -> None:
+        super().__init__(*args,**kwargs)
+        self.velocity = pygame.math.Vector2(0, 0)
+        self.ignore_collisions : bool = False
+
+    def on_collideX(self, collider: "DynamicEntity"):
+        """
+        Return true if collision
+        """
+        return False
+
+    def on_collideY(self, collider: "DynamicEntity"):
+        """
+        Return true if collision
+        """
+        return False
+
+    def move_by_velocity(self, dt) -> None:
+        self.set_position(
+            self.rect.x + self.velocity.x * dt, self.rect.y + self.velocity.y * dt
+        )

batFramework/easingController.py

@@ -1,58 +1,58 @@
-import pygame
-import batFramework as bf
-from functools import lru_cache
-from typing import Callable,Any
-
-
-@lru_cache(maxsize=None)
-def process_value(progress: float, p0: float, p1: float, p2: float, p3: float) -> float:
-    if p0 == 0 and p1 == 0 and p2 == 1 and p3 == 1:  # Linear easing control points
-        return progress
-    t = progress
-    t_inv = 1.0 - t
-    t2 = t * t
-    t3 = t * t2
-    t_inv2 = t_inv * t_inv
-    return 3 * t_inv2 * t * p1 + 3 * t_inv * t2 * p3 + t3
-
-
-class EasingController(bf.Timer):
-    def __init__(
-        self,
-        duration: float = 1,
-        easing: bf.easing = bf.easing.LINEAR,
-        update_callback=None,
-        end_callback: Callable[[], Any] = None,
-        loop: int = 0,
-        register:str="global"
-    ) -> None:
-        self.easing_function = easing
-        self.update_callback: Callable[[float], Any] = update_callback
-        self.value: float = 0.0
-        super().__init__(duration, end_callback, loop, register)
-
-    def get_value(self) -> float:
-        return self.value
-
-    def start(self, force: bool = False):
-        super().start(force)
-        self.value = 0
-
-    def update(self, dt: float) -> None:
-        if self.get_progression() == 1:
-            return
-        super().update(dt)
-        if self.get_progression() == 0:
-            return
-        if self.easing_function == bf.easing.LINEAR: # avoid calculating if linear (just use progression as is)
-            self.value = self.get_progression()
-        else:
-            self.value = process_value(self.get_progression(), *self.easing_function.control_points)
-        
-        if self.update_callback:
-            self.update_callback(self.value)
-
-    def end(self):
-        if self.update_callback:
-            self.update_callback(1)
-        super().end()
+import pygame
+import batFramework as bf
+from functools import lru_cache
+from typing import Callable,Any
+
+
+@lru_cache(maxsize=None)
+def process_value(progress: float, p0: float, p1: float, p2: float, p3: float) -> float:
+    if p0 == 0 and p1 == 0 and p2 == 1 and p3 == 1:  # Linear easing control points
+        return progress
+    t = progress
+    t_inv = 1.0 - t
+    t2 = t * t
+    t3 = t * t2
+    t_inv2 = t_inv * t_inv
+    return 3 * t_inv2 * t * p1 + 3 * t_inv * t2 * p3 + t3
+
+
+class EasingController(bf.Timer):
+    def __init__(
+        self,
+        duration: float = 1,
+        easing: bf.easing = bf.easing.LINEAR,
+        update_callback=None,
+        end_callback: Callable[[], Any] = None,
+        loop: int = 0,
+        register:str="global"
+    ) -> None:
+        self.easing_function = easing
+        self.update_callback: Callable[[float], Any] = update_callback
+        self.value: float = 0.0
+        super().__init__(duration, end_callback, loop, register)
+
+    def get_value(self) -> float:
+        return self.value
+
+    def start(self, force: bool = False):
+        super().start(force)
+        self.value = 0
+
+    def update(self, dt: float) -> None:
+        if self.get_progression() == 1:
+            return
+        super().update(dt)
+        if self.get_progression() == 0:
+            return
+        if self.easing_function == bf.easing.LINEAR: # avoid calculating if linear (just use progression as is)
+            self.value = self.get_progression()
+        else:
+            self.value = process_value(self.get_progression(), *self.easing_function.control_points)
+        
+        if self.update_callback:
+            self.update_callback(self.value)
+
+    def end(self):
+        if self.update_callback:
+            self.update_callback(1)
+        super().end()