batframework 1.0.8a2__py3-none-any.whl → 1.0.8a4__py3-none-any.whl

batFramework/cutsceneBlocks.py

@@ -1,6 +1,7 @@
 import batFramework as bf
-from .cutscene import Cutscene,CutsceneManager
-
+from .cutscene import Cutscene, CutsceneManager
+from .transition import *
+from typing import Optional,Callable
 
 # Define the base CutsceneBlock class
 class CutsceneBlock:
@@ -17,18 +18,18 @@ class CutsceneBlock:
         self.ended = False
         self.started = False
 
-    def get_scene_at(self,index):
-        return bf.CutsceneManager().manager._scenes[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):
         """
@@ -90,17 +91,13 @@ 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] = blocks
+        self.blocks: list[CutsceneBlock] = list(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:
@@ -108,32 +105,14 @@ 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)
 
 
@@ -144,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(name = "scene_transition_block",duration=duration, end_callback=self.end)
+        self.timer = bf.Timer(transition.duration, self.end)
 
     # Start the scene transition block
     def start(self):
@@ -160,17 +140,30 @@ 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:
+        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 : Optional[Callable]) -> None:
+        self.function = func
+
+    def start(self):
+        super().start()
+        if self.function : self.function()
+        self.end()

batFramework/dynamicEntity.py

@@ -2,22 +2,30 @@ import pygame
 import batFramework as bf
 from typing import Self
 
+
 class DynamicEntity(bf.Entity):
     def __init__(
         self,
-        size : None|tuple[int,int]=None,
-        no_surface : bool   =False,
-        surface_flags : int =0,
-        convert_alpha : bool=False
+        size: None | tuple[int, int] = None,
+        surface_flags: int = 0,
+        convert_alpha: bool = False,*args,**kwargs
     ) -> None:
-        super().__init__(size,no_surface,surface_flags,convert_alpha)
+        super().__init__(size, surface_flags, convert_alpha,*args,**kwargs)
         self.velocity = pygame.math.Vector2(0, 0)
 
-    def on_collideX(self, collider: Self):
+    def on_collideX(self, collider: "DynamicEntity"):
+        """
+        Return true if collision
+        """
         return False
 
-    def on_collideY(self, collider: Self):
+    def on_collideY(self, collider: "DynamicEntity"):
+        """
+        Return true if collision
+        """
         return False
 
-    def move_by_velocity(self)->None:
-        self.set_position(self.rect.x + self.velocity.x, self.rect.y + self.velocity.y)
+    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

@@ -0,0 +1,58 @@
+import pygame
+import batFramework as bf
+from functools import lru_cache
+from .enums import easing
+
+
+@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,
+        easing_function: easing = easing.LINEAR,
+        duration: float = 1,
+        update_callback=None,
+        end_callback=None,
+        loop: bool = False,
+    ) -> None:
+        self.easing_function = easing_function
+        self.update_callback = update_callback
+        self.value: float = 0.0
+        super().__init__(duration, end_callback, loop)
+
+    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 == easing.LINEAR:
+            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()

batFramework/entity.py

@@ -1,123 +1,74 @@
+from typing import Any, Self
 import pygame
 import batFramework as bf
-from typing import Any
+from .object import Object
+
+
+class Entity(Object):
+    """
+    Basic entity class
+    """
 
-class Entity:
-    instance_num = 0
     def __init__(
         self,
-        size : None|tuple[int,int]=None,
-        no_surface : bool   =False,
-        surface_flags : int =0,
-        convert_alpha : bool=False
+        size: None | tuple[int, int] = None,
+        surface_flags: int = 0,
+        convert_alpha: bool = False,
+        *args,
+        **kwargs,
     ) -> None:
-        self.convert_alpha = convert_alpha
-        if size is None:
-            size= (100,100)
-            
-        if no_surface:
-            self.surface = None
-        else:
-            self.surface = (pygame.Surface(size, surface_flags))
-
-        if convert_alpha and self.surface is not None:
+        super().__init__()
+        self.visible: bool = True
+        self.rect.size = (10, 10) if size is None else size
+        self.convert_alpha: bool = convert_alpha
+        self.surface_flags: int = surface_flags
+        self.blit_flags: int = 0
+        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))
-
-        self.uid: Any = Entity.instance_num
-        self.tags: list[str] = []
-        self.parent_scene: bf.Scene | None = None
-        self.rect = pygame.FRect(0, 0, *size)
-        
-        self.visible = True
-        self._debug_color : tuple = bf.color.DARK_RED
-        self.render_order = 0
-        self.z_depth = 1
-        Entity.instance_num += 1
-
-    def get_bounding_box(self):
-        yield (self.rect,self._debug_color)
+            self.surface.fill((0, 0, 0, 0))
 
-    def set_debug_color(self, color):
-        self._debug_color = color
-
-    def set_visible(self, value: bool):
-        self.visible = value
-
-    def set_parent_scene(self, scene):
-        self.parent_scene = scene
-
-    def do_when_added(self):
-        pass
+    def set_alpha(self, alpha: int) -> Self:
+        self.surface.set_alpha(min(max(0, alpha), 255))
+        return self
 
-    def do_when_removed(self):
-        pass
+    def get_alpha(self) -> int:
+        return self.surface.get_alpha()
 
-    def set_position(self, x, y):
-        self.rect.topleft = (x, y)
+    def set_surface_flags(self, surface_flags: int) -> Self:
+        self.surface_flags = surface_flags
         return self
 
-    def set_x(self,x):
-        self.rect.x = x
+    def set_convert_alpha(self, value: bool) -> Self:
+        self.convert_alpha = value
         return self
 
-    def set_y(self,y):
-        self.rect.y = y
+    def set_blit_flags(self, blit_flags: int) -> Self:
+        self.blit_flags = blit_flags
         return self
 
-    def set_center(self, x, y):
-        self.rect.center = (x, y)
-        return self
+    def get_debug_outlines(self):
+        if self.visible:
+            yield (self.rect, self.debug_color)
 
-    def set_uid(self, uid):
-        self.uid = uid
+    def set_render_order(self, render_order: int) -> Self:
+        self.render_order = render_order
+        if self.parent_scene:
+            self.parent_scene.sort_entities()
         return self
 
-    def add_tag(self, *tags):
-        for tag in tags:
-            if tag not in self.tags:
-                self.tags.append(tag)
-        self.tags.sort()
+    def set_visible(self, value: bool) -> Self:
+        self.visible = value
         return self
 
-    def remove_tag(self, *tags):
-        self.tags = [tag for tag in self.tags if tag not in tags]
-        self.tags.sort()
-
-    def has_tag(self, tag) -> bool:
-        return tag in self.tags
-
-    def process_event(self, event: pygame.Event)->bool:
+    def draw(self, camera: bf.Camera) -> None:
         """
-        Returns bool : True if the method is blocking (no propagation to next children of the scene)
+        Draw the entity onto the camera surface
         """
-        self.do_process_actions(event)
-        res = self.do_handle_event(event)
-        self.do_reset_actions()
-        return res
-
-    def do_process_actions(self,event : pygame.Event)->None:
-        pass
-
-    def do_reset_actions(self)->None:
-        pass
-    
-    def do_handle_event(self, event: pygame.Event) -> bool:
-        return False
-
-    def update(self, dt: float):
-        self.do_update(dt)
-
-    def do_update(self,dt:float):
-        pass
-
-    def draw(self, camera: bf.Camera) -> int:
-        if not self.visible:
-            return False
-        if not self.surface or not camera.intersects(self.rect):
-            return False
+        if not self.visible or not camera.rect.colliderect(self.rect):
+            return
         camera.surface.blit(
             self.surface,
-            tuple(round(i * self.z_depth) for i in camera.transpose(self.rect).topleft),
+            camera.world_to_screen(self.rect),
+            special_flags=self.blit_flags,
         )
-        return True

batFramework/enums.py

@@ -0,0 +1,113 @@
+from enum import Enum
+
+
+class color:
+    WHITE = (255, 255, 255)
+    LIGHTER_GRAY = (236, 240, 241)
+    LIGHT_GRAY = (189, 195, 199)
+    DARK_GRAY = (66, 66, 66)
+    DARKER_GRAY = (23, 23, 23)
+    BLACK = (0, 0, 0)
+
+    TURQUOISE = (26, 188, 156)
+    TURQUOISE_SHADE = (22, 160, 133)
+
+    GREEN = (46, 204, 113)
+    GREEN_SHADE = (39, 174, 96)
+
+    BLUE = (52, 152, 219)
+    BLUE_SHADE = (41, 128, 185)
+
+    PURPLE = (155, 89, 182)
+    PURPLE_SHADE = (142, 68, 173)
+
+    CHARCOAL = (52, 73, 94)
+    CHARCOAL_SHADE = (44, 62, 80)
+
+    GOLD = (241, 196, 15)
+    GOLD_SHADE = (243, 156, 18)
+
+    ORANGE = (230, 126, 34)
+    ORANGE_SHADE = (211, 84, 0)
+
+    RED = (231, 76, 60)
+    RED_SHADE = (192, 57, 43)
+
+    CLOUD = (236, 240, 241)
+    CLOUD_SHADE = (189, 195, 199)
+
+    CONCRETE = (149, 165, 166)
+    CONCRETE_SHADE = (127, 140, 141)
+
+    # GB
+    DARKER_GB = (27, 42, 9)
+    DARK_GB = (14, 69, 11)
+    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)
+    EASE_OUT = (0.5, 1, 0.5, 1)
+    EASE_IN_OUT = (0.55, 0, 0.45, 1)
+    EASE_IN_OUT_ELASTIC = (0.39, -0.55, 0.3, 1.3)
+
+    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"
+    CENTER = "center"
+    TOP = "top"
+    BOTTOM = "bottom"
+    TOPLEFT = "topleft"
+    TOPRIGHT = "topright"
+    MIDLEFT = "midleft"
+    MIDRIGHT = "midright"
+    BOTTOMLEFT = "bottomleft"
+    BOTTOMRIGHT = "bottomright"
+
+
+class direction(Enum):
+    LEFT = 0
+    UP = 1
+    RIGHT = 2
+    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
+    HOLDING = 2
+
+
+class textMode(Enum):
+    ALPHABETICAL = 0
+    NUMERICAL = 1
+    ALPHANUMERIC = 3

batFramework/fontManager.py

@@ -0,0 +1,65 @@
+from .utils import Singleton
+
+# put font stuff here later
+import pygame
+import os
+import batFramework as bf
+
+
+class FontManager(metaclass=Singleton):
+    def __init__(self):
+        pygame.font.init()
+        self.DEFAULT_TEXT_SIZE = 16
+        self.MIN_FONT_SIZE = 8
+        self.MAX_FONT_SIZE = 64
+        self.DEFAULT_ANTIALIAS = False
+        self.FONTS = {}
+
+    def set_antialias(self, value: bool):
+        self.DEFAULT_ANTIALIAS = value
+
+    def set_default_text_size(self, size: int):
+        self.DEFAULT_TEXT_SIZE = size
+
+    def init_font(self, raw_path: str | None):
+        try:
+            if raw_path is not None:
+                self.load_font(raw_path if raw_path else None, None)
+            self.load_font(raw_path)
+        except FileNotFoundError:
+            self.load_sysfont(raw_path)
+            self.load_sysfont(raw_path, None)
+
+    def load_font(self, path: str | None, name: str | None = ""):
+        if path is not None:
+            path = bf.ResourceManager().get_path(path)  # convert path if given
+        filename = None
+        if path is not None:
+            filename = os.path.basename(path).split(".")[0]
+
+        # get filename if path is given, else None
+        if name != "":
+            filename = name  # if name is not given, name is the filename
+        self.FONTS[filename] = {}
+        # fill the dict
+        for size in range(self.MIN_FONT_SIZE, self.MAX_FONT_SIZE, 2):
+            self.FONTS[filename][size] = pygame.font.Font(path, size=size)
+
+    def load_sysfont(self, font_name: str | None, key: str | None = ""):
+        if key == "":
+            key = font_name
+        if font_name is None or pygame.font.match_font(font_name) is None:
+            raise FileNotFoundError(f"Requested font '{font_name}' was not found")
+        self.FONTS[font_name] = {}
+
+        for size in range(self.MIN_FONT_SIZE, self.MAX_FONT_SIZE, 2):
+            self.FONTS[key][size] = pygame.font.SysFont(font_name, size=size)
+
+    def get_font(
+        self, name: str | None = None, text_size: int = 12
+    ) -> pygame.Font | None:
+        if not name in self.FONTS:
+            return None
+        if not text_size in self.FONTS[name]:
+            return None
+        return self.FONTS[name][text_size]

batFramework/gui/__init__.py

@@ -1,14 +1,22 @@
 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
+from .clickableWidget import ClickableWidget
 from .root import Root
 from .shape import Shape
-from .frame import Frame
+from .meter import Meter
 from .label import Label
+from .dialogueBox import DialogueBox
+from .textInput import TextInput
 from .button import Button
-from .debugger import Debugger
+from .debugger import *
 from .layout import *
 from .container import Container
 from .indicator import *
 from .toggle import Toggle
+from .radioButton import RadioButton, RadioVariable
+from .slider import Slider