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

batFramework/__init__.py

@@ -9,8 +9,8 @@ from .utils import Utils as utils
 from .tileset import Tileset
 from .timeManager import TimeManager,Timer,SceneTimer
 from .easingController import EasingController
-from .cutscene import Cutscene, CutsceneManager
-import batFramework.cutsceneBlocks
+import batFramework.cutscene
+from .cutsceneManager import CutsceneManager
 from .audioManager import AudioManager
 import batFramework.transition as transition
 from .action import Action
@@ -67,7 +67,8 @@ def init(
     print_version()
     pygame.display.set_caption(window_caption)
     init_screen(resolution, flags, vsync)
-
+    pygame.mixer.init()
+    
     ResourceManager().set_resource_path(
         resource_path if resource_path is not None else "."
     )

batFramework/audioManager.py

@@ -1,7 +1,7 @@
 import batFramework as bf
 import pygame
 
-pygame.mixer.init()
+
 
 
 class AudioManager(metaclass=bf.Singleton):

batFramework/cutscene.py

@@ -1,129 +1,44 @@
 import batFramework as bf
-from typing import TYPE_CHECKING,Self
-
-class CutsceneBlock: ...
-
-if TYPE_CHECKING:
-    from .cutsceneBlocks import CutsceneBlock
-
-
-class Cutscene: ...
-
-
-class CutsceneManager(metaclass=bf.Singleton):
-    def __init__(self) -> None:
-        self.current_cutscene: Cutscene = None
-        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
-
-    def process_event(self, event):
-        if self.current_cutscene:
-            self.current_cutscene.process_event(event)
-
-    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
-            self.current_cutscene.on_enter()
-            self.current_cutscene.init_blocks()
-            self.current_cutscene.play()
-
-    def enable_player_control(self) -> None:
-        pass
-
-    def disable_player_control(self) -> None:
-        pass
-    
-    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
-                if self.cutscenes:
-                    self.play(self.cutscenes.pop(0))
-                else:
-                    self.current_cutscene = None
-
 
 class Cutscene:
-    def __init__(self) -> None:
-        self.cutscene_blocks : list[CutsceneBlock] = []
-        self.block_index = 0
-        self.end_blocks: list[CutsceneBlock] = []
-        self.ended = False
-
-    def on_enter(self):
-        pass
-
-    def on_exit(self):
-        pass
-
-    def init_blocks(self):
-        pass
-
-    def add_blocks(self, *blocks: CutsceneBlock)->Self:
-        self.cutscene_blocks.extend(blocks)
-        return self
-        
-    def add_end_blocks(self, *blocks: CutsceneBlock)->Self:
-        _ = [block.set_parent_cutscene(self) for block in blocks]
-        self.end_blocks.extend(blocks)
-        return self
-        
-    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):
-        return bf.CutsceneManager().manager.get_scene(name)
-
-    def add_block(self, *blocks: CutsceneBlock):
-        for block in blocks:
-            block.set_parent_cutscene(self)
-            self.cutscene_blocks.append(block)
-
-    def process_event(self, event):
-        if not self.ended and self.block_index < len(self.cutscene_blocks):
-            self.cutscene_blocks[self.block_index].process_event(event)
-
-    def play(self):
-        self.block_index = 0
-        if self.cutscene_blocks:
-            self.cutscene_blocks[self.block_index].start()
+    def __init__(self,*cutscenes):
+        self.is_over : bool = False
+        self.sub_cutscenes : list[Cutscene] = list(cutscenes)
+        self.sub_index = -1
+
+    def start(self):
+        if self.sub_cutscenes:
+            self.sub_index = 0
+            self.sub_cutscenes[self.sub_index].start()
         else:
-            self.ended
-
-    def update(self, dt):
-        if self.ended:
-            return
-        self.cutscene_blocks[self.block_index].update(dt)
-        if self.cutscene_blocks[self.block_index].has_ended():
-            self.block_index += 1
-            if self.block_index == len(self.cutscene_blocks):
-                if not self.end_blocks:
-                    self.ended = True
-                    return
-                else:
-                    self.cutscene_blocks.extend(self.end_blocks)
-                    self.end_blocks = []
-            self.cutscene_blocks[self.block_index].start()
-
-    def has_ended(self):
-        return self.ended
+            self.end()
+
+    def process_event(self,event):
+        if self.sub_index > 0: 
+            self.sub_cutscenes[self.sub_index].process_event(event)
+            
+    def update(self,dt):
+        if self.sub_index > 0: 
+            self.sub_cutscenes[self.sub_index].update(dt)
+            if self.sub_cutscenes[self.sub_index].is_over:
+                self.sub_index +=1
+                if self.sub_index >= len(self.sub_cutscenes):
+                    self.end()
+            
+    def end(self):
+        self.is_over = True
+
+
+class Wait(Cutscene):
+    def __init__(self,duration:float,scene_name:str="global"):
+        super().__init__()
+        self.duration = duration
+        self.scene_name = scene_name
+    def start(self):
+        self.timer = bf.SceneTimer(duration=self.duration,end_callback=self.end,scene_name=self.scene_name)
+        self.timer.start()
+
+
+
+# class TransitionToScene(bf.Cutscene):
+    # def __init__(self,scene_name:str,)

batFramework/cutsceneManager.py

@@ -0,0 +1,31 @@
+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
+
+    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()
+
+    def update(self,dt):
+        if self.current_cutscene:
+            self.current_cutscene.update(dt)
+            if self.current_cutscene.is_over:
+                self.current_cutscene = None

batFramework/easingController.py

@@ -2,6 +2,7 @@ import pygame
 import batFramework as bf
 from functools import lru_cache
 from .enums import easing
+from typing import Callable,Any
 
 
 @lru_cache(maxsize=None)
@@ -22,11 +23,11 @@ class EasingController(bf.Timer):
         easing_function: easing = easing.LINEAR,
         duration: float = 1,
         update_callback=None,
-        end_callback=None,
+        end_callback: Callable[[],Any]=None,
         loop: bool = False,
     ) -> None:
         self.easing_function = easing_function
-        self.update_callback = update_callback
+        self.update_callback: Callable[[float],Any] = update_callback
         self.value: float = 0.0
         super().__init__(duration, end_callback, loop)
 

batFramework/enums.py

@@ -1,4 +1,8 @@
 from enum import Enum
+import pygame
+
+playerInput = [pygame.KEYDOWN,pygame.MOUSEBUTTONDOWN,pygame.KEYUP,pygame.MOUSEBUTTONUP]
+
 
 
 class color:
@@ -111,4 +115,6 @@ class textMode(Enum):
     ALPHABETICAL = 0
     NUMERICAL = 1
     ALPHANUMERICAL = 3
-    
+
+
+

batFramework/gui/button.py

@@ -1,13 +1,13 @@
 from .label import Label
 import batFramework as bf
-from typing import Self, Callable
+from typing import Self, Callable,Any
 from .clickableWidget import ClickableWidget
 import pygame
 from math import ceil
 
 
 class Button(Label, ClickableWidget):
-    def __init__(self, text: str = "", callback: None | Callable = None) -> None:
+    def __init__(self, text: str = "", callback: Callable[[],Any] = None) -> None:
         super().__init__(text=text)
         self.set_callback(callback)
 

batFramework/gui/clickableWidget.py

@@ -1,6 +1,6 @@
 from .label import Label
 import batFramework as bf
-from typing import Self, Callable
+from typing import Self, Callable, Any
 from .interactiveWidget import InteractiveWidget
 from .shape import Shape
 import pygame
@@ -10,7 +10,7 @@ from math import ceil
 class ClickableWidget(Shape, InteractiveWidget):
     _cache: dict = {}
 
-    def __init__(self, callback: None | Callable = None, *args, **kwargs) -> None:
+    def __init__(self, callback: Callable[[],Any] = None, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
         self.callback = callback
         self.is_pressed: bool = False
@@ -28,8 +28,15 @@ class ClickableWidget(Shape, InteractiveWidget):
         self.set_relief(self.unpressed_relief)
 
     def get_min_required_size(self) -> tuple[float, float]:
-        return self.rect.size.inflate(0,self.unpressed_relief)
-
+        if not (self.autoresize_w or self.autoresize_h):
+            return self.rect.size
+        
+        res = super().get_min_required_size()
+        res = res[0],res[1]+self.unpressed_relief
+        print("hey",res)
+        return res[0] if self.autoresize_w else self.rect.w, (
+            res[1] if self.autoresize_h else self.rect.h
+        )
 
 
     def set_unpressed_relief(self, relief: int) -> Self:
@@ -111,7 +118,7 @@ class ClickableWidget(Shape, InteractiveWidget):
     def is_enabled(self) -> bool:
         return self.enabled
 
-    def set_callback(self, callback: Callable) -> Self:
+    def set_callback(self, callback: Callable[[],Any]) -> Self:
         self.callback = callback
         return self
 

batFramework/gui/constraints/constraints.py

@@ -41,16 +41,16 @@ class MinWidth(Constraint):
         self.min_width = width
 
     def on_removal(self, child_widget: Widget) -> None:
-            child_widget.set_autoresize_w(False)
+            return
+            # child_widget.set_autoresize_w(False)
 
     def evaluate(self, parent_widget, child_widget):
         res =  child_widget.rect.width >= self.min_width
-        if not res:
-            child_widget.set_autoresize_w(False)
+        # if not res:
+            # child_widget.set_autoresize_w(False)
         return res
 
     def apply_constraint(self, parent_widget, child_widget):
-        child_widget.set_autoresize_w(True)
         child_widget.set_size((self.min_width, None))
 
     def __eq__(self,other:"Constraint")->bool:

batFramework/gui/container.py

@@ -106,7 +106,7 @@ class Container(Shape, InteractiveWidget):
         return self
 
     def top_at(self, x: float | int, y: float | int) -> "None|Widget":
-        if self.visible and self.rect.collidepoint(x, y):
+        if self.rect.collidepoint(x, y):
             for child in reversed(self.children):
                 result = child.top_at(x, y)
                 if result is not None:

batFramework/gui/debugger.py

@@ -1,5 +1,5 @@
 from .label import Label
-from typing import Self
+from typing import Self,Callable,Any
 import batFramework as bf
 import pygame
 
@@ -11,8 +11,8 @@ def convert_to_int(*args):
 class Debugger(Label):
     def __init__(self) -> None:
         super().__init__("")
-        self.static_data: dict = {}
-        self.dynamic_data: dict = {}
+        self.static_data: dict[str,Any] = {}
+        self.dynamic_data: dict[str,Callable[[],str]] = {}
         self.refresh_rate = 10
         self.refresh_counter: float = 0
         self.add_tags("debugger")
@@ -26,18 +26,18 @@ class Debugger(Label):
         self.static_data[key] = str(data)
         self.update_text()
 
-    def add_dynamic(self, key: str, func) -> None:
+    def add_dynamic(self, key: str, func:Callable[[],str]) -> None:
         self.dynamic_data[key] = func
         self.update_text()
 
-    def remove_static(self, key) -> bool:
+    def remove_static(self, key:str) -> bool:
         try:
             self.static_data.pop(key)
             return True
         except KeyError:
             return False
 
-    def remove_dynamic(self, key) -> bool:
+    def remove_dynamic(self, key:str) -> bool:
         try:
             self.dynamic_data.pop(key)
             return True

batFramework/gui/image.py

@@ -37,6 +37,12 @@ class Image(Shape):
             )
         super().build()
 
+    def get_min_required_size(self) -> tuple[float, float]:
+        res = self.rect.size
+        return self.inflate_rect_by_padding((0, 0, *res)).size
+
+
+
 
     def from_path(self, path: str) -> Self:
         tmp = bf.ResourceManager().get_image(path, self.convert_alpha)

batFramework/gui/indicator.py

@@ -1,5 +1,5 @@
 from .shape import Shape
-from typing import Any, Self
+from typing import Any, Self, Callable
 import pygame
 from .widget import Widget
 from .interactiveWidget import InteractiveWidget
@@ -37,7 +37,7 @@ class ToggleIndicator(Indicator):
         # TODO aspect ratio would be good right about here
         # self.add_constraint(ConstraintAspectRatio(1))
 
-    def set_callback(self, callback) -> Self:
+    def set_callback(self, callback : Callable[[bool],Any]) -> Self:
         self.callback = callback
         return self
 

batFramework/gui/layout.py

@@ -273,7 +273,7 @@ class RowFill(Row):
         super().__init__(gap, spacing)
 
     def arrange(self) -> None:
-        if self.parent.autoresize_h :
+        if self.parent.autoresize_w :
            super().arrange() 
            return
         if not self.parent or not self.parent.children:

batFramework/gui/radioButton.py

@@ -45,9 +45,9 @@ class RadioVariable:
     def __init__(self) -> None:
         self.buttons: list[RadioButton] = []
         self.value = None
-        self.modify_callback: Callable[[Any],] = None
+        self.modify_callback: Callable[[bool],Any] = None
 
-    def set_modify_callback(self, callback) -> Self:
+    def set_modify_callback(self, callback:Callable[[bool],Any]) -> Self:
         self.modify_callback = callback
         return self
 

batFramework/gui/root.py

@@ -138,6 +138,15 @@ class Root(InteractiveWidget):
         if self.hovered and isinstance(self.hovered, InteractiveWidget):
             self.hovered.on_enter()
 
+    def apply_updates(self):
+        if any(child.dirty_shape for child in self.children):
+            self.dirty_shape = True  # Mark layout as dirty if any child changed size
+
+        if self.dirty_shape:
+            for child in self.children:
+                child.apply_updates()
+            self.dirty_shape = False
+
     def draw(self, camera: bf.Camera) -> None:
         super().draw(camera)
         if (

batFramework/gui/slider.py

@@ -66,7 +66,7 @@ class Slider(Button):
         super().__init__(text, None)
         self.gap: float | int = 0
         self.spacing: bf.spacing = bf.spacing.MANUAL
-        self.modified_callback = None
+        self.modified_callback : Callable[[float],Any] = None
         self.meter: SliderMeter = SliderMeter()
         self.handle = SliderHandle()
         self.add(self.meter, self.handle)
@@ -102,7 +102,7 @@ class Slider(Button):
         self.dirty_shape = True
         return self
 
-    def set_modify_callback(self, callback) -> Self:
+    def set_modify_callback(self, callback : Callable[[float],Any]) -> Self:
         self.modified_callback = callback
         return self
 
@@ -175,6 +175,7 @@ class Slider(Button):
         if not self.text_rect:
             self.text_rect.size = self._get_text_rect_required_size()
         w, h = self.text_rect.size
+        h+=self.unpressed_relief
         return self.inflate_rect_by_padding((0, 0, w + gap + self.meter.get_min_required_size()[1], h)).size
 
     def _build_layout(self) -> None:

batFramework/gui/styleManager.py

@@ -39,6 +39,12 @@ class StyleManager(metaclass=Singleton):
         self.lookup = {key: False for key in self.lookup}
         self.update()
 
+    def update_forced(self):
+       for widget in self.widgets:
+            for style in self.styles:
+                style.apply(widget)
+            self.lookup[widget] = True
+
     def update(self):
         for widget in self.widgets:
             if self.lookup[widget]:

batFramework/gui/textInput.py

@@ -140,7 +140,7 @@ class TextInput(Label, InteractiveWidget):
         lines = self.text.split('\n')
         line_x, line_y = self.cursor_position
 
-        height = self.font_object.get_point_size()
+        height = self.font_object.get_linesize()
 
         cursor_y = self.get_padded_rect().__getattribute__(self.alignment.value)[1] - self.rect.top
         cursor_y += line_y * height
@@ -248,10 +248,8 @@ class TextInput(Label, InteractiveWidget):
             return
         cursor_rect = self.get_cursor_rect()
         cursor_rect.move_ip(-self.scroll)
-
         
         pygame.draw.rect(self.surface, bf.color.CLOUD, cursor_rect.inflate(2,2))
-
         pygame.draw.rect(self.surface, self.text_color, cursor_rect)
 
     def paint(self) -> None:
@@ -272,9 +270,9 @@ class TextInput(Label, InteractiveWidget):
 
         
         if cursor_rect.right > area.right+self.scroll.x:
-            self.scroll.x=cursor_rect.right - area.right
+            self.scroll.x=cursor_rect.right - area.right - cursor_rect.w*2 
         elif cursor_rect.x < self.scroll.x+area.left:
-            self.scroll.x= cursor_rect.left - area.left 
+            self.scroll.x= cursor_rect.left - area.left
         self.scroll.x = max(self.scroll.x,0)
 
         if cursor_rect.bottom > area.bottom + self.scroll.y:

batFramework/gui/toggle.py

@@ -1,12 +1,12 @@
 from .button import Button
 from .indicator import Indicator, ToggleIndicator
 import batFramework as bf
-from typing import Self
+from typing import Self,Callable,Any
 import pygame
 
 
 class Toggle(Button):
-    def __init__(self, text: str = "", callback=None, default_value: bool = False) -> None:
+    def __init__(self, text: str = "", callback : Callable[[bool],Any]=None, default_value: bool = False) -> None:
         self.value: bool = default_value
         self.indicator: ToggleIndicator = ToggleIndicator(default_value)
         self.gap: float | int = 0
@@ -59,7 +59,7 @@ class Toggle(Button):
                 self.indicator.get_min_required_size()[0],
                 self.text_rect.w + self.font_object.point_size + (self.gap if self.text else 0),
             ),
-            self.text_rect.h,
+            self.text_rect.h+self.unpressed_relief,
         )
         return self.inflate_rect_by_padding((0, 0, *size)).size
 

batFramework/gui/widget.py

@@ -174,11 +174,11 @@ class Widget(bf.Drawable, metaclass=WidgetMeta):
         return self.rect.bottom - self.padding[3]
 
     def get_debug_outlines(self):
-        if not self.visible:
-            return
-        yield (self.rect, self.debug_color)
-        if any(self.padding):
-            yield (self.get_padded_rect(), self.debug_color)
+        if self.visible:
+            if any(self.padding):
+                yield (self.get_padded_rect(), self.debug_color)
+            else:
+                yield (self.rect, self.debug_color)
         for child in self.children:
             yield from child.get_debug_outlines()
 
@@ -272,11 +272,11 @@ class Widget(bf.Drawable, metaclass=WidgetMeta):
     def top_at(self, x: float | int, y: float | int) -> "None|Widget":
         if self.children:
             for child in reversed(self.children):
-                if child.visible:
-                    r = child.top_at(x, y)
-                    if r is not None:
-                        return r
-        return self if self.visible and self.rect.collidepoint(x, y) else None
+                # if child.visible:
+                r = child.top_at(x, y)
+                if r is not None:
+                    return r
+        return self if  self.rect.collidepoint(x, y) else None
 
     def add(self, *children: "Widget") -> Self:
         self.children.extend(children)
@@ -387,20 +387,27 @@ class Widget(bf.Drawable, metaclass=WidgetMeta):
 
 
     def apply_updates(self) -> None:
-        # Step 1: Build shape if needed
+
+        if self.dirty_constraints:
+            self.resolve_constraints()  # Finalize positioning based on final size
+            self.dirty_constraints = False
+
+        # Build shape if needed
         if self.dirty_shape:
             self.build()  # Finalize widget size
             self.dirty_shape = False
             self.dirty_surface = True
+            self.dirty_constraints = True
             # Propagate dirty_constraints to children in case size affects their position
             for child in self.children:
                 child.dirty_constraints = True
 
-        # Step 2: Resolve constraints now that size is finalized
+        # Resolve constraints now that size is finalized
         if self.dirty_constraints:
             self.resolve_constraints()  # Finalize positioning based on final size
             self.dirty_constraints = False
 
+
         # Step 3: Paint the surface if flagged as dirty
         if self.dirty_surface:
             self.paint()

batFramework/manager.py

@@ -74,6 +74,8 @@ class Manager(bf.SceneManager):
             if event.key == pygame.K_p:
                 self.print_status()
                 return
+        self.cutsceneManager.process_event(event)
+        if event.consumed: return
         super().process_event(event)
         if not event.consumed:
             if event.type == pygame.QUIT:

batFramework/renderGroup.py

@@ -8,13 +8,13 @@ from typing import Self, Iterator, Callable
 """
 
 
-class RenderGroup(bf.Entity):
+class RenderGroup(bf.Drawable):
     def __init__(
-        self, entity_iterator: Callable[[], Iterator[bf.Entity]], blit_flags: int = 0
+        self, entity_iterator: Callable[[], Iterator[bf.Drawable]], blit_flags: int = 0
     ) -> None:
         super().__init__()
         self.entity_iterator = entity_iterator
-        self.set_blit_flags(blit_flags)
+        # self.set_blit_flags(blit_flags)
         self.set_debug_color("white")
 
     def get_debug_outlines(self):

batFramework/sceneManager.py

@@ -171,6 +171,9 @@ class SceneManager:
 
     def process_event(self, event: pygame.Event):
 
+        if self.current_transitions and event in bf.enums.playerInput:
+            return
+
         if event.type in self.shared_events:
             [s.process_event(event) for s in self.scenes]
         else:

batFramework/timeManager.py

@@ -1,13 +1,12 @@
 import batFramework as bf
-from typing import Self
-from typing import Callable, Union, Self
+from typing import Callable, Union, Self,Any
 
 
 class Timer:
     _count: int = 0
     _available_ids: set[int] = set()
 
-    def __init__(self, duration: Union[float, int], end_callback: Callable, loop: bool = False, register: str = "global") -> None:
+    def __init__(self, duration: Union[float, int], end_callback: Callable[[],Any], loop: bool = False, register: str = "global") -> None:
         if Timer._available_ids:
             self.uid = Timer._available_ids.pop()
         else:

batFramework/transition.py

@@ -1,5 +1,5 @@
 import batFramework as bf
-from typing import Self
+from typing import Self,Callable,Any
 import pygame
 
 """
@@ -23,24 +23,24 @@ class Transition:
             update_callback=self.update,
             end_callback=self.end,
         )
-        self.start_callback = None
-        self.update_callback = None
-        self.end_callback = None
+        self.start_callback : Callable[[],Any] = None
+        self.update_callback : Callable[[float],Any]= None
+        self.end_callback : Callable[[],Any]= None
         self.source: pygame.Surface = None
         self.dest: pygame.Surface = None
 
     def __repr__(self) -> str:
         return f"Transition {self.__class__},{self.duration}"
 
-    def set_start_callback(self, func) -> Self:
+    def set_start_callback(self, func : Callable[[],Any]) -> Self:
         self.start_callback = func
         return self
 
-    def set_update_callback(self, func) -> Self:
+    def set_update_callback(self, func : Callable[[float],Any]) -> Self:
         self.update_callback = func
         return self
 
-    def set_end_callback(self, func) -> Self:
+    def set_end_callback(self, func : Callable[[],Any]) -> Self:
         self.end_callback = func
         return self
 
@@ -118,7 +118,7 @@ class FadeColor(Transition):
     def transition_to_end(self):
         self.next_step(self.end)
 
-    def next_step(self, callback=None) -> None:
+    def next_step(self, callback : Callable[[],Any]=None) -> None:
         self.index += 1
         if callback:
             callback()

batFramework/triggerZone.py

@@ -1,8 +1,8 @@
 import batFramework as bf
-
+from typing import Callable,Any
 
 class TriggerZone(bf.Entity):
-    def __init__(self, size, trigger, callback, active=True) -> None:
+    def __init__(self, size, trigger, callback: Callable[[Any],Any], active=True) -> None:
         super().__init__(size, True)
         self.set_debug_color(bf.color.RED)
         self.active = active
@@ -13,7 +13,7 @@ class TriggerZone(bf.Entity):
         self.trigger = trigger
         return self
 
-    def set_callback(self, callback):
+    def set_callback(self, callback: Callable[[Any],Any]):
         self.callback = callback
         return self
 

{batframework-1.0.9a2.dist-info → batframework-1.0.9a4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: batframework
-Version: 1.0.9a2
+Version: 1.0.9a4
 Summary: Pygame framework for making games easier.
 Author-email: Turan Baturay <baturayturan@gmail.com>
 Project-URL: Homepage, https://github.com/TuranBaturay/batFramework

{batframework-1.0.9a2.dist-info → batframework-1.0.9a4.dist-info}/RECORD

@@ -1,63 +1,63 @@
-batFramework/__init__.py,sha256=5gUzzhO3tXPaaaxVBl7Q-cwKouh12agOa9GXzBipUgU,2576
+batFramework/__init__.py,sha256=Fc9uFdDnmhJ1bhCI550T9cu_Zy-ni-avSs5pLmPEgiM,2595
 batFramework/action.py,sha256=919IVYKviLyVYDtQL7oZvlVuE_aodjJCuwz6fGi5sCk,8420
 batFramework/actionContainer.py,sha256=qy6-YY3iX26KJ8NqFMSYo6JExohD8HFk0sC1qhb7qA8,2602
 batFramework/animatedSprite.py,sha256=IWE8zUgpFaqQPUr7iOUo7TJ_E10aUaMNqlIqv8dW87E,4242
 batFramework/animation.py,sha256=_XcH6r3TVQZUcLbhzUnTNlXrjy-J-nYiRmFpxvTYEoc,1934
-batFramework/audioManager.py,sha256=8tKSf4huZe5tgH98qHlKoFNjXPGDQNJho6PKfSCe7JA,3869
+batFramework/audioManager.py,sha256=ANn6GXDm5bcThih0KD8jrF54Re20A6kxHQrVJu9QYxc,3850
 batFramework/camera.py,sha256=tSy9n20QLeJD3Uz352q-uejzAHPtQczvahaNz7APJcY,9408
 batFramework/character.py,sha256=AK5sQLvAOY3X4-7vzeHeIO5WDFsubn_TADLYxmYc0Qo,789
 batFramework/constants.py,sha256=x8a0GqBJdiwMEjlVohyL3AWHaSxyrBy-4pucVKVNakg,1354
-batFramework/cutscene.py,sha256=zra-hvAVY5buBPfFiog4psvLZW07qCt8LZzd7Vd-4qM,3858
-batFramework/cutsceneBlocks.py,sha256=3jtmTpV48NKCu-Qgjg7KN5KnwXn0kycIQ7t7G3RH3VE,4862
+batFramework/cutscene.py,sha256=oc6Ktl2t7zO-oH-HWU18wB5ABMyWg7-h3jREGKpcu50,1315
+batFramework/cutsceneManager.py,sha256=mvBR4KOv6KV9eHzhYH7r6IJMVLjM71C30C2OuvwbuSU,945
 batFramework/drawable.py,sha256=5We2ITq3M5ERG22-iQw7Mo_1LNo0nqma1P13tvphDjY,2197
 batFramework/dynamicEntity.py,sha256=SjXShy5aT4cQzjlTem05zSQRiNeq52AUXEBVodEG6gI,736
-batFramework/easingController.py,sha256=4N8GIp1fsaWBUlDxXx3SMwOq1Mrhn10MZZIO51_CRnk,1677
+batFramework/easingController.py,sha256=ql_nt8unwUZLy7MC7unzDn5eTW44VtjrOTCDs8WS0eY,1750
 batFramework/entity.py,sha256=wMQKR6IxQ69vtPY4nGsz7WnY9ApPhO_VY08IYx6yUu8,2910
-batFramework/enums.py,sha256=r7vAWBm5g3qrvN-WzBN-2ErNKFFqQ5mTrib2GjmDHmE,2083
+batFramework/enums.py,sha256=xkT4yepdLLQn-5YWoSxhHamXE7w_M-GIw47dWWHfKIs,2185
 batFramework/fontManager.py,sha256=M7h6AVq9Fwr51UTCFoGsg_PSurdjByA4w8qouXq4EKE,2254
-batFramework/manager.py,sha256=vu7TfDnJu08_I-pPWSn450NDrMY-LysLe8y3t2fTy_o,4404
+batFramework/manager.py,sha256=TQ0Q1f_GbQE8h4G9zCNQgtNTKNCj630S43Ai4e0yZik,4488
 batFramework/particle.py,sha256=Aps9eJNdFag-TlduMSezKp4ocFQVvI6iZ98chhdhbgE,3081
-batFramework/renderGroup.py,sha256=_VDvmP4iB-XarFJo_Uh5YKwWq1cazHmOBmTXZkqKk40,2020
+batFramework/renderGroup.py,sha256=CO8LtTP1gYI1i_8OwmMk2SlU33Nv4iXnHvK0RVK3D24,2026
 batFramework/resourceManager.py,sha256=0cOIAFXT7UzzvgHn9QkWcXsTp8H2bIS70NvvgpBL2_4,3554
 batFramework/scene.py,sha256=0E7omgNUEl5Uhbx8iO3exyCy4p1MC7bSvqfwncW4KMw,11281
-batFramework/sceneManager.py,sha256=_VPPi0WepH8_NQuwq6d4gfTFdmku3VxrDkJ8cu3oxqU,7008
+batFramework/sceneManager.py,sha256=GCGt7DYoty_wX2LVEhv0C6TaNyNWhKvWocwOqxUIBXc,7099
 batFramework/scrollingSprite.py,sha256=_1-hp7y3pC5m8g2VhFVgGOuJsOkOi8adhQiI2Rb0uPY,4133
 batFramework/sprite.py,sha256=Cz8qzl8jR8y33DUSCObJQOk5e8PcZeavtFhBdR2TogU,1627
 batFramework/stateMachine.py,sha256=wC-5xbKvf-vGm_N16X9KhgMya5915GyVXL79uk5Bapw,1359
 batFramework/tileset.py,sha256=3AJBWHx90PC43BdLYCBFm811XBrMvWoB-nsUgyo6s-I,1728
-batFramework/timeManager.py,sha256=XcqPs_74pjXafi6oNJe8W85SVfXTfPmOZOQyLOuyt8I,4987
-batFramework/transition.py,sha256=-1cyk-7Fbm0U2Z4Y2jjpLHwJ2khM1VxIMcfk2bBEo-M,6655
-batFramework/triggerZone.py,sha256=wIxkvO0cVVupQsJIPOD_-ofqwLnu1TLNK-n6oNXB1E8,579
+batFramework/timeManager.py,sha256=TT_pynpS1wYmSK6s8ksQTt-coR9EeB0mYimhq5yrK08,4975
+batFramework/transition.py,sha256=tKthKfGyv1V39eIiNGSGL---KcZXix3YIGg9RirOcLc,6809
+batFramework/triggerZone.py,sha256=MaPp20UoyRHAMiN0_sBanJJ_0cWnYXZEeY-BEaDTDxQ,652
 batFramework/utils.py,sha256=vfndaYn4wMy0W746C6oCWCvnUyk9BxPL2vIpGyEDssU,9958
 batFramework/gui/__init__.py,sha256=OFAKZkafWX-BfDjF4MILmigVT1lywnsfH2pOIJwUybY,691
 batFramework/gui/animatedLabel.py,sha256=KePSSd6bTeJ5UXoPUpvY7QRx5Uah5-qpBDGby6xRgqU,2752
-batFramework/gui/button.py,sha256=IcljwLTIGsCcwCm1mFYBPxZDAU721TiLkOysldultHQ,1798
-batFramework/gui/clickableWidget.py,sha256=4bsa5_OrxFTHNyD3LJOB75gFdjJv3wcV1VMjEf78BrU,7176
-batFramework/gui/container.py,sha256=0did6s0tUqAIi7yX4y26YOMRrAiE3YiIPgfySLLbhBo,6297
-batFramework/gui/debugger.py,sha256=0VTQvhSD5zLjbVhs97ldeBLXqnFLlua-zTCpWB9OBGQ,3928
+batFramework/gui/button.py,sha256=p_wMcaijpUbNuoRBNkhplrZqsB3gdl7mVpduR-UFm_4,1803
+batFramework/gui/clickableWidget.py,sha256=8wHuH_aBuNrzG5_YZLfmtc65n0jtlDrJV3rFd9M4QSg,7477
+batFramework/gui/container.py,sha256=2EIPpumiswH365Tq-3iF2FzApY2T440O9qijAx7SkpU,6280
+batFramework/gui/debugger.py,sha256=0w2B4qQ5MeFwwP46zG7KTzIFzh2fmtU10UH96b_hT9Y,3997
 batFramework/gui/draggableWidget.py,sha256=SKG7oMInZ_GTnrbv2T0aqlppuiuLX1tkVSCQJtRMlk8,1392
-batFramework/gui/image.py,sha256=7IRvalA6QQz7SYI9h4y4-ryWa9EOxZM3sc10-OZyCPc,1770
-batFramework/gui/indicator.py,sha256=R2SY4HHYnHdvAQZUWVtV-nvpZ_IyEx6CCmb-DDCL1J0,1586
+batFramework/gui/image.py,sha256=CPDSF7Fz1zmGAK-ii7R4MIAD5EZCnPw4mpD_cGv77U8,1925
+batFramework/gui/indicator.py,sha256=31QAyvT9w-eCWUSoK4pV-4TsTzFvkY_g5snoeI1hATM,1619
 batFramework/gui/interactiveWidget.py,sha256=ww9WsR2Y87og7NtnzCcyc1zIPE-Bjtn0YZ0SOfKMUbQ,6633
 batFramework/gui/label.py,sha256=6hkD54lrp8ZPnKm75001NnfTli22rSKUdWlC-1bRIdE,11672
-batFramework/gui/layout.py,sha256=-7UgOktSkiyWPfuhTK7I8umqQm7ST69VKgbODejBZtc,21661
+batFramework/gui/layout.py,sha256=MJjcz6fjTWtt4-Td0dAqKd3XRDlRJ5QaDpRbdYEj1w8,21661
 batFramework/gui/meter.py,sha256=RFzAhSzR3O-Pw0wjdfApWGWFQSJoYa4WohkiREDAAJc,2395
-batFramework/gui/radioButton.py,sha256=rROl9mtUa-m220R5qZ85NBPZS7nPVx-azhqijJ-XhCo,2411
-batFramework/gui/root.py,sha256=xe0dGGEaFV80Y6oY2ma-HCYKCBcbO5CbVu4MtWPShxE,4755
+batFramework/gui/radioButton.py,sha256=DgCtN1j1s2rUITpdYqArqQ36NnNGump7FiTe_ndEzJg,2436
+batFramework/gui/root.py,sha256=r8dhI2xd2h5bUbTe4x_On77BTTZ7Sf8qY5wWJimWXds,5078
 batFramework/gui/shape.py,sha256=PSQRqa8jYA8VsBXRQcpcCuEvTYmWDW8zJkzA_eRFPIo,9349
-batFramework/gui/slider.py,sha256=Bz99zzFPtI359S3YzjKQK5pVvIyPCBBwwfW92esahCk,8386
+batFramework/gui/slider.py,sha256=rt0f2jnxyd89uepyBqBueP3qw6y9ZTIRGXipI9fhBs4,8467
 batFramework/gui/style.py,sha256=OeLbft0RkIslQ2IcZpBeF6TaQDONIoBcAHj_Bkh9gFw,131
-batFramework/gui/styleManager.py,sha256=rALKJ-AmRbDAiyu8hVAYRAlkQxw677DiPoNKJZ4xtJ4,1245
-batFramework/gui/textInput.py,sha256=RMamEneCaixRVfDU4ctqeYBif4j9cIYgDcLYecikub4,10988
-batFramework/gui/toggle.py,sha256=225hIUTOZEHnv8UvhEPLxcA11TmEsrZlb0hsmycpQbY,3939
-batFramework/gui/widget.py,sha256=jisyWi2wMSyEE8VuU3do6aW66PXzORe4nOTtR5WiXsA,14422
+batFramework/gui/styleManager.py,sha256=ZWkGBkNQngJVU8k9OHrTeKzGYc5Hj4JAVATrU1MufB4,1423
+batFramework/gui/textInput.py,sha256=v4r110mYmPj0RB97DsCG81U06dUd-7cnNeBj-mnbdiE,11002
+batFramework/gui/toggle.py,sha256=icvg0GY0pErCZPWoje_SO7L6Ik_sM--XHTM-pUAwdY8,3997
+batFramework/gui/widget.py,sha256=KrkQH8Z2tSVcnCHhet-xXlHy3SqSjHByBQVNoTOs54E,14597
 batFramework/gui/constraints/__init__.py,sha256=qqXE8nnSrEvCSeHdqY8UYPZLetqdubFPI7IdZuh35QE,26
-batFramework/gui/constraints/constraints.py,sha256=dUuwWNgOoAGm2PKAxjGy8ubldZ2ih0k4_ViBLd2AXE8,29726
+batFramework/gui/constraints/constraints.py,sha256=XFvrjFFN1nmbYzI6l54DlZkrRP-wWXfgXrtE4T5egCA,29707
 batFramework/templates/__init__.py,sha256=8XN-7JwYFKTRx_lnUL_If3spwgn5_2b7bwmrRRBPON0,46
 batFramework/templates/character.py,sha256=4UEcegUIeIgj48sVgzyRcT6yjpFOZ8Q_gHTtiB5j6kw,1348
 batFramework/templates/states.py,sha256=WeomVrQ10vHxVCj9Wnk1PcinKyb871uV910mQe287kI,5370
-batframework-1.0.9a2.dist-info/LICENCE,sha256=A65iXbMDbOxQLDNOODJLqA7o5RxszYlEqIgNSzBQRf4,1073
-batframework-1.0.9a2.dist-info/METADATA,sha256=gya1wLTBekCRpHE2BNIxD1qoIIyQ11j7iZizpAOLRjI,1694
-batframework-1.0.9a2.dist-info/WHEEL,sha256=R06PA3UVYHThwHvxuRWMqaGcr-PuniXahwjmQRFMEkY,91
-batframework-1.0.9a2.dist-info/top_level.txt,sha256=vxAKBIk1oparFTxeXGBrgfIO7iq_YR5Fv1JvPVAIwmA,13
-batframework-1.0.9a2.dist-info/RECORD,,
+batframework-1.0.9a4.dist-info/LICENCE,sha256=A65iXbMDbOxQLDNOODJLqA7o5RxszYlEqIgNSzBQRf4,1073
+batframework-1.0.9a4.dist-info/METADATA,sha256=JIZ73b5rzLH38fgZtEOrFNIVvQpMoI5dpT0Y7CZJ5iU,1694
+batframework-1.0.9a4.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+batframework-1.0.9a4.dist-info/top_level.txt,sha256=vxAKBIk1oparFTxeXGBrgfIO7iq_YR5Fv1JvPVAIwmA,13
+batframework-1.0.9a4.dist-info/RECORD,,

{batframework-1.0.9a2.dist-info → batframework-1.0.9a4.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.5.0)
+Generator: setuptools (75.6.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

batFramework/cutsceneBlocks.py

@@ -1,169 +0,0 @@
-import batFramework as bf
-from .cutscene import Cutscene, CutsceneManager
-from .transition import *
-from typing import Optional,Callable
-
-# Define the base CutsceneBlock class
-class CutsceneBlock:
-    """
-    Base class for cutscene blocks. Represents a unit of action in a cutscene.
-    """
-
-    # Constructor for the CutsceneBlock
-    def __init__(self) -> None:
-        # Callback function, parent cutscene, and state variables
-        self.callback = None
-        self.parent_cutscene: Cutscene = None
-        self.get_flag = CutsceneManager().get_flag
-        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_current_scene(self):
-        return CutsceneManager().manager.get_current_scene()
-
-    def get_scene(self, name):
-        return CutsceneManager().manager.get_scene(name)
-
-    # Set the parent cutscene for this block
-    def set_parent_cutscene(self, parent):
-        """
-        Set the parent cutscene for this block.
-
-        Args:
-            parent: The parent cutscene object.
-        """
-        self.parent_cutscene = parent
-
-    # Process an event (placeholder implementation, to be overridden in subclasses)
-    def process_event(self, event):
-        """
-        Process an event for this cutscene block.
-
-        Args:
-            event: The event to be processed.
-        """
-        pass
-
-    # Update the block (placeholder implementation, to be overridden in subclasses)
-    def update(self, dt):
-        """
-        Update the cutscene block.
-
-        Args:
-            dt: Time elapsed since the last update.
-        """
-        pass
-
-    # Start the block
-    def start(self):
-        """
-        Start the cutscene block.
-        """
-        self.started = True
-
-    # Mark the block as ended
-    def end(self):
-        """
-        Mark the cutscene block as ended.
-        """
-        self.ended = True
-
-    # Check if the block has ended
-    def has_ended(self):
-        """
-        Check if the cutscene block has ended.
-
-        Returns:
-            bool: True if the block has ended, False otherwise.
-        """
-        return self.ended
-
-
-# Define the ParallelBlock class, a type of CutsceneBlock
-class ParallelBlock(CutsceneBlock):
-    """
-    Represents a parallel execution block for multiple Cutscene blocks.
-    """
-
-    def __init__(self, *blocks) -> None:
-        super().__init__()
-        # List of blocks to run in parallel
-        self.blocks: list[CutsceneBlock] = list(blocks)
-
-    # Start the parallel block (override the base class method)
-    def start(self):
-        super().start()
-        # Start each block in parallel
-        for block in self.blocks:
-            block.start()
-
-    # Process an event for each block in parallel
-    def process_event(self, event):
-        _ = [b.process_event(event) for b in self.blocks]
-
-    # Update each block in parallel
-    def update(self, dt):
-        _ = [b.update(dt) for b in self.blocks]
-
-    # Check if all blocks have ended
-    def has_ended(self):
-        return all(b.has_ended() for b in self.blocks)
-
-
-# Define the SceneTransitionBlock class, a type of CutsceneBlock
-class SceneTransitionBlock(CutsceneBlock):
-    """
-    Represents a scene transition Cutscene block.
-    """
-
-    # Constructor for SceneTransitionBlock
-    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.index = index
-        # Timer to handle the end of the transition
-        self.timer = bf.Timer(transition.duration, self.end)
-
-    # Start the scene transition block
-    def start(self):
-        """
-        Start the scene transition block.
-        """
-        super().start()
-        # Initiate the scene transition
-        if self.get_current_scene().name == self.target_scene:
-            self.end()
-            return
-        CutsceneManager().manager.transition_to_scene(
-            self.target_scene, self.transition, self.index
-        )
-        # 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 : Optional[Callable]) -> None:
-        self.function = func
-
-    def start(self):
-        super().start()
-        if self.function : self.function()
-        self.end()