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

batFramework/cutsceneBlocks.py

@@ -1,6 +1,5 @@
 import batFramework as bf
-from .cutscene import Cutscene, CutsceneManager
-from .transition import *
+from .cutscene import Cutscene,CutsceneManager
 
 
 # Define the base CutsceneBlock class
@@ -18,18 +17,18 @@ class CutsceneBlock:
         self.ended = False
         self.started = False
 
-    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 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 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):
         """
@@ -91,13 +90,17 @@ 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:
@@ -105,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)
 
 
@@ -123,16 +144,15 @@ class SceneTransitionBlock(CutsceneBlock):
     """
 
     # Constructor for SceneTransitionBlock
-    def __init__(
-        self, scene, transition: Transition = Fade(0.1), index: int = 0
-    ) -> None:
+    def __init__(self, scene, transition, duration, **kwargs) -> None:
         super().__init__()
         # Target scene, transition type, duration, and additional keyword arguments
         self.target_scene = scene
         self.transition = transition
-        self.index = index
+        self.duration = duration
+        self.kwargs = kwargs
         # Timer to handle the end of the transition
-        self.timer = bf.Timer(transition.duration, self.end)
+        self.timer = bf.Timer(name = "scene_transition_block",duration=duration, end_callback=self.end)
 
     # Start the scene transition block
     def start(self):
@@ -140,32 +160,17 @@ 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, self.index
+            self.target_scene, self.transition, duration=self.duration, **self.kwargs
         )
         # Start the timer to handle the end of the transition
         self.timer.start()
 
-
-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()
+    def end(self):
+        return super().end()

batFramework/debugger.py

@@ -0,0 +1,48 @@
+import batFramework as bf
+import pygame
+
+
+class Debugger(bf.Label):
+    def __init__(self, manager) -> None:
+        super().__init__()
+        self.manager: bf.Manager = manager
+        self.refresh_rate = 0
+        self._refresh_counter = 0
+        self.dynamic_data = {}
+        self.static_data = {}
+        self.render_order = 99
+        self.set_outline_color((20, 20, 20))
+        # self.set_background_color((0,0,0,0))
+        self.set_text_color("white")
+        # self.set_padding((30,30))
+        self.set_refresh_rate(20)
+        self.add_dynamic_data("FPS", lambda: str(round(self.manager.get_fps())))
+        self.add_dynamic_data("BLITS", lambda: str(self.parent_scene.blit_calls))
+        self.set_visible(False)
+
+    def set_refresh_rate(self, val: int):
+        self.refresh_rate = val
+
+    def update(self, dt: float):
+        visible = self.manager._debugging == 1
+        self.set_visible(visible)
+        if not visible:
+            return
+        self._refresh_counter -= dt * 60
+        if self._refresh_counter < 0:
+            self._refresh_counter = self.refresh_rate
+            self._refresh_debug_info()
+
+    def add_dynamic_data(self, key, func):
+        self.dynamic_data[key] = func
+
+    def set_static_data(self, key, value):
+        self.static_data[key] = value
+
+    def _refresh_debug_info(self):
+        lines = []
+        lines.extend([f"{key}:{value}" for key, value in self.static_data.items()])
+        lines.extend([f"{key}:{func()}" for key, func in self.dynamic_data.items()])
+        debug_text = "\n".join(lines)
+        self.set_text(debug_text)
+        self.update_surface()  # Update the surface after modifying the text

batFramework/dynamicEntity.py

@@ -2,15 +2,15 @@ import pygame
 import batFramework as bf
 from typing import Self
 
-
 class DynamicEntity(bf.Entity):
     def __init__(
         self,
-        size: None | tuple[int, int] = None,
-        surface_flags: int = 0,
-        convert_alpha: bool = False,
+        size : None|tuple[int,int]=None,
+        no_surface : bool   =False,
+        surface_flags : int =0,
+        convert_alpha : bool=False
     ) -> None:
-        super().__init__(size, surface_flags, convert_alpha)
+        super().__init__(size,no_surface,surface_flags,convert_alpha)
         self.velocity = pygame.math.Vector2(0, 0)
 
     def on_collideX(self, collider: Self):
@@ -19,7 +19,5 @@ class DynamicEntity(bf.Entity):
     def on_collideY(self, collider: Self):
         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
-        )
+    def move_by_velocity(self)->None:
+        self.set_position(self.rect.x + self.velocity.x, self.rect.y + self.velocity.y)

batFramework/easing.py

@@ -0,0 +1,71 @@
+from enum import Enum
+import pygame
+import batFramework as bf
+
+class Easing(Enum):
+    EASE_IN     = (0.12, 0, 0.39, 0)
+    EASE_OUT    = (0.61, 1, 0.88, 1)
+    EASE_IN_OUT = (0.37, 0, 0.63, 1)
+    EASE_IN_OUT_ELASTIC = (.7,-0.5,.3,1.5)
+    LINEAR      = (1, 1, 0, 0)
+    # Add more easing functions as needed
+
+    def __init__(self, *control_points):
+        self.control_points = control_points
+
+class EasingAnimation(bf.Timer):
+    _cache = {}
+    def __init__(
+        self,
+        name:str=None,
+        easing_function:Easing=Easing.LINEAR,
+        duration:int=100,
+        update_callback=None,
+        end_callback=None,
+        loop:bool=False,
+        reusable:bool=False
+    ):
+        self.easing_function = easing_function
+        self.update_callback = update_callback
+        self.value = 0.0
+        super().__init__(name,duration,loop,end_callback,reusable)
+        
+    def get_value(self):
+        return self.value
+
+    def start(self):
+        self.value =  0
+        super().start() # self.elapsed_progress set to 0 here    
+        
+    def update(self)->bool:
+        if super().update():
+            return True# If timer ended now, end() is called. So don't process value.  
+        self._process_value()
+        # if self.name == 0: print("UPDATING (callback) in easing")
+        if self.update_callback: self.update_callback(self.value)
+        return False
+
+    def end(self):
+        # Call update 1 last time with the last value
+
+        self.elapsed_progress = 1
+        self._process_value()
+        if self.update_callback: self.update_callback(self.value)
+        self.value =  0
+        super().end() # sets elapsed_progress to 0
+
+    def _process_value(self):
+        p0, p1, p2, p3 = self.easing_function.control_points
+        cache_key = (self.elapsed_progress, p0, p1, p2, p3)
+        if cache_key in EasingAnimation._cache:
+            y = EasingAnimation._cache[cache_key]
+        else:
+            t = self.elapsed_progress
+            t_inv = 1.0 - t
+            t2 = t * t
+            t3 = t * t2
+            t_inv2 = t_inv * t_inv
+
+            y = 3 * t_inv2 * t * p1 + 3 * t_inv * t2 * p3 + t3
+            EasingAnimation._cache[cache_key] = y
+        self.value = y

batFramework/entity.py

@@ -1,67 +1,123 @@
-from typing import Any, Self
 import pygame
 import batFramework as bf
-from .object import Object
+from typing import Any
 
-class Entity(Object):
-    """
-    Basic entity class
-    """
+class Entity:
+    instance_num = 0
     def __init__(
         self,
-        size: None | tuple[int, int] = None,
-        surface_flags: int = 0,
-        convert_alpha: bool = False,
-        *args,
-        **kwargs,
+        size : None|tuple[int,int]=None,
+        no_surface : bool   =False,
+        surface_flags : int =0,
+        convert_alpha : bool=False
     ) -> 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.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:
             self.surface = self.surface.convert_alpha()
-            self.surface.fill((0, 0, 0, 0))
+            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
+        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)
 
-    def get_alpha(self)->int:
-        return self.surface.get_alpha()
+    def set_debug_color(self, color):
+        self._debug_color = color
+
+    def set_visible(self, value: bool):
+        self.visible = value
 
-    def set_surface_flags(self, surface_flags: int) -> Self:
-        self.surface_flags = surface_flags
+    def set_parent_scene(self, scene):
+        self.parent_scene = scene
+
+    def do_when_added(self):
+        pass
+
+    def do_when_removed(self):
+        pass
+
+    def set_position(self, x, y):
+        self.rect.topleft = (x, y)
         return self
 
-    def set_convert_alpha(self, value: bool) -> Self:
-        self.convert_alpha = value
+    def set_x(self,x):
+        self.rect.x = x
         return self
 
-    def set_blit_flags(self, blit_flags: int) -> Self:
-        self.blit_flags = blit_flags
+    def set_y(self,y):
+        self.rect.y = y
         return self
 
-    def set_render_order(self, render_order: int) -> Self:
-        self.render_order = render_order
-        if self.parent_scene:
-            self.parent_scene.sort_entities()
+    def set_center(self, x, y):
+        self.rect.center = (x, y)
         return self
 
-    def set_visible(self, value: bool) -> Self:
-        self.visible = value
+    def set_uid(self, uid):
+        self.uid = uid
         return self
 
-    def draw(self, camera: bf.Camera) -> None:
+    def add_tag(self, *tags):
+        for tag in tags:
+            if tag not in self.tags:
+                self.tags.append(tag)
+        self.tags.sort()
+        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:
         """
-        Draw the entity onto the camera surface
+        Returns bool : True if the method is blocking (no propagation to next children of the scene)
         """
-        if not self.visible or not camera.rect.colliderect(self.rect): return
+        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
         camera.surface.blit(
             self.surface,
-            camera.world_to_screen(self.rect),
-            special_flags=self.blit_flags,
+            tuple(round(i * self.z_depth) for i in camera.transpose(self.rect).topleft),
         )
+        return True

batFramework/gui/__init__.py

@@ -2,19 +2,13 @@ from .constraints import *
 from .widget import Widget
 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 .meter import Meter
+from .frame import Frame
 from .label import Label
-from .dialogueBox import DialogueBox
-from .textInput import TextInput
 from .button import Button
-from .debugger import *
+from .debugger import Debugger
 from .layout import *
 from .container import Container
 from .indicator import *
 from .toggle import Toggle
-from .radioButton import RadioButton,RadioVariable
-from .slider import Slider

batFramework/gui/button.py

@@ -1,12 +1,84 @@
 from .label import Label
 import batFramework as bf
-from typing import Self, Callable
-from .clickableWidget import ClickableWidget
+from types import FunctionType
+from typing import Self
+from .interactiveWidget import InteractiveWidget
 import pygame
-from math import ceil
 
-
-class Button(Label, ClickableWidget):
-    def __init__(self, text: str, callback: None | Callable = None) -> None:
+class Button(Label,InteractiveWidget):
+    _cache = {}
+    
+    def __init__(self, text: str, callback : FunctionType =None) -> None:
+        # Label.__init__(self,text) 
+        self.callback = callback    
+        self.click_action = bf.Action("click").add_mouse_control(1)
+        self.hover_action = bf.Action("hover").add_mouse_control(pygame.MOUSEMOTION)
+        self.is_hovered : bool = False
+        self.is_clicking : bool = False
         super().__init__(text=text)
-        self.set_callback(callback)
+        self.set_debug_color("cyan")
+
+
+    def set_callback(self,callback : FunctionType = None)->Self:
+        self.callback = callback
+        return self
+
+    def on_get_focus(self):
+        super().on_get_focus()
+        self.build()
+
+    def on_lose_focus(self):
+        super().on_lose_focus()
+        self.build()
+
+    def to_string_id(self)->str:
+        return f"Button({self._text})"   
+
+    def click(self)->None:
+        if self.callback and not self.is_clicking:
+            self.is_clicking = True
+            self.callback()
+            self.is_clicking = False
+            
+            
+    def do_process_actions(self,event):
+        self.click_action.process_event(event)
+        self.hover_action.process_event(event)
+
+    def do_reset_actions(self):
+        self.click_action.reset()
+        self.hover_action.reset()
+
+    def do_handle_event(self,event)->None:
+        res = False
+        if self.click_action.is_active():
+            root = self.get_root()
+            if root.hovered ==  self:
+                if not self.is_focused :  self.get_focus()
+                self.click()
+        elif self.hover_action.is_active():
+            root = self.get_root()
+            if root:
+                if self.is_hovered and root.hovered != self:
+                    self.is_hovered = False
+                    self.build()
+                if not self.is_hovered and root.hovered == self:
+                    self.is_hovered = True
+                    self.build()
+        return res
+
+
+        
+    def build(self)->None:
+        super().build()
+        if self.is_hovered:
+            hover_surf = Button._cache.get(self.surface.get_size(),None)
+            if hover_surf is None:
+                hover_surf = pygame.Surface(self.surface.get_size()).convert_alpha()
+                hover_surf.fill((30,30,30,0))
+                Button._cache[self.surface.get_size()] = hover_surf
+            self.surface.blit(hover_surf,(0,0),special_flags = pygame.BLEND_ADD)
+
+
+    def apply_contraints(self)->None:
+        super().apply_contraints()