batframework 1.0.9a11__py3-none-any.whl → 1.1.0__py3-none-any.whl

batFramework/cutscene.py

@@ -1,253 +1,119 @@
 import batFramework as bf
-from .transition import Transition
-from typing import Callable,Any
+
+
+class CutsceneBlock:
+    ...
+
 
 class Cutscene:
-    def __init__(self):
-        """
-        Create a base Cutscene (ends immediately)
-        """
-
-    def start(self):
-        """
-        Called by the manager or the parent cutscene
-        Has to return to blank init state
-        """
-        self.end()
-
-    def process_event(self,event):
-        pass
+    ...
+
+
+class CutsceneManager(metaclass=bf.Singleton):
+    def __init__(self, manager) -> None:
+        self.current_cutscene: Cutscene = None
+        self.cutscenes : list[bf.Cutscene] = [] 
+        self.manager: bf.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 update(self,dt):
+    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()
+        self.manager.set_sharedVar("in_cutscene", True)
+
+    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
+                    self.manager.set_sharedVar("in_cutscene", False)
+
+class Cutscene:
+    def __init__(self,*blocks) -> None:
+        self.cutscene_blocks: list[CutsceneBlock] = list(blocks)
+        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 end(self):
-        """
-        Mark self as over
-        """
-        self.is_over = True
-
-class Sequence(Cutscene):
-    def __init__(self,*cutscenes):
-        self.sub_cutscenes :list[Cutscene] = list(cutscenes)
-        self.index = 0
-
-    def start(self):
-        self.is_over = False
-        self.index = 0
-        if self.sub_cutscenes:
-            self.sub_cutscenes[0].start()
-
-    def process_event(self,event):
-        """
-        propagate process event for current sub cutscene
-        """
-        if self.index >0 and not self.is_over:
-            self.sub_cutscenes[self.index].process_event(event)
-
-        
-
-    def update(self,dt):
-        """
-        Update current sub cutscene (if any)
-        if current is over, start next one
-        if current was last, then end self
-        """
-        if self.index < len(self.sub_cutscenes):
-            self.sub_cutscenes[self.index].update(dt)
-            if self.sub_cutscenes[self.index].is_over:
-                self.index += 1
-                if self.index == len(self.sub_cutscenes):
-                    self.end()
+    def add_end_block(self,block):
+        block.set_parent_cutscene(self)
+        self.end_blocks.append(block)
+
+    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: list[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()
+        else:
+            self.ended
+
+    def update(self, dt):
+        if self.ended:
+            return
+        # print("cutscene update",self.cutscene_blocks[self.block_index])
+        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
-                self.sub_cutscenes[self.index].start()
+                else:
+                    self.cutscene_blocks.extend(self.end_blocks)
+                    self.end_blocks = []
+            self.cutscene_blocks[self.block_index].start()
+
+            # print("NEXT BLOCK")
+
+    def has_ended(self):
+        return self.ended
 
 
-class Parallel(Cutscene):
-    def __init__(self,*cutscenes:Cutscene):
-        self.sub_cutscenes : list[Cutscene] = list(cutscenes) 
-
-    def start(self):
-        self.is_over = False
-        if not self.sub_cutscenes:
-            self.end()
-        for s in self.sub_cutscenes:
-            s.start()        
-
-    def update(self,dt):
-        for s in self.sub_cutscenes:
-            s.update(dt)
-        if all(s.is_over for s in self.sub_cutscenes):
-            self.end()
-
-class Wait(Cutscene):
-    def __init__(self,duration:float,scene_name:str="global"):
-        self.duration = duration
-        self.scene_name = scene_name
-    def start(self):
-        self.is_over = False
-        self.timer = bf.SceneTimer(duration=self.duration,end_callback=self.end,scene_name=self.scene_name)
-        self.timer.start()
-
-
-
-class TransitionToScene(Cutscene):
-    def __init__(self,scene_name:str,transition:Transition):
-        self.scene_name = scene_name
-        self.transition: Transition = transition
-
-    def start(self):
-        self.is_over = False
-        bf.CutsceneManager().manager.transition_to_scene(self.scene_name,self.transition)
-        bf.Timer(self.transition.duration,end_callback=self.end).start()
-
-
-
-
-
-
-class GlideWorldCameraFromTo(Cutscene):
-    def __init__(self,start:tuple[float,float], stop:tuple[float,float],duration:float=1,easing:bf.easing=bf.easing.EASE_IN_OUT,scene_name:str=None):
-        super().__init__()
-        self.scene =  None
-        self.scene_name = scene_name
-        self.start_pos = start
-        self.stop_pos = stop
-        self.controller = bf.EasingController(duration,easing,update_callback=self.internal,end_callback=self.end)
-
-
-    def start(self):
-        self.is_over = False
-        if self.scene_name is None:
-            self.scene_name = bf.CutsceneManager().manager.get_scene_at(0).name
-
-        self.scene = bf.CutsceneManager().manager.get_scene(self.scene_name)
-        self.controller.start()
-
-
-    def internal(self,progression:float):
-        self.scene.camera.set_center(
-            self.start_pos[0]+progression*(self.stop_pos[0]-self.start_pos[0]),
-            self.start_pos[1]+progression*(self.stop_pos[1]-self.start_pos[1])
-        )
-
-    def end(self):
-        if self.scene:
-            self.scene.camera.set_center(self.stop_pos[0],self.stop_pos[1])
-        
-        super().end()
-
-
-
-class Function(Cutscene):
-    def __init__(self, function:Callable[[],Any],*args,**kwargs):
-        super().__init__()
-        self.function:Callable[[],Any] = function
-        self.args = args
-        self.kwargs = kwargs
-        
-    def start(self):
-        self.is_over = False
-        self.function(*self.args,**self.kwargs)
-        self.end()
-
-class GlideCamera(Cutscene):
-    def __init__(
-        self,
-        start: tuple[float, float] | None = None,
-        stop: tuple[float, float] | None = None,
-        delta: tuple[float, float] | None = None,
-        duration: float = 1,
-        easing: bf.easing = bf.easing.EASE_IN_OUT,
-        scene_name: str | None = None,
-        layer_name: str = "world",
-    ):
-        super().__init__()
-        self.scene = None
-        self.layer = None
-        self.scene_name = scene_name
-        self.layer_name = layer_name
-        self.start_pos = start
-        self.stop_pos = stop
-        self.delta = delta
-        self.controller = bf.EasingController(
-            duration, easing, update_callback=self.internal, end_callback=self.end
-        )
-
-    def start(self):
-        self.is_over = False
-
-        if self.scene_name is None:
-            self.scene_name = bf.CutsceneManager().manager.get_scene_at(0).name
-
-        self.scene = bf.CutsceneManager().manager.get_scene(self.scene_name)
-        self.layer = self.scene.get_layer(self.layer_name)
-
-        if not self.layer:
-            raise ValueError(f"Layer '{self.layer_name}' not found in scene '{self.scene_name}'.")
-
-        # Fallback to current camera position
-        if self.start_pos is None:
-            self.start_pos = self.layer.camera.get_center()
-
-        # Compute stop_pos if not set
-        if self.stop_pos is None:
-            if self.delta is not None:
-                self.stop_pos = (
-                    self.start_pos[0] + self.delta[0],
-                    self.start_pos[1] + self.delta[1],
-                )
-            else:
-                raise ValueError("Must specify either stop or delta position")
-
-        self.controller.start()
-
-    def internal(self, progression: float):
-        self.layer.camera.set_center(
-            self.start_pos[0] + progression * (self.stop_pos[0] - self.start_pos[0]),
-            self.start_pos[1] + progression * (self.stop_pos[1] - self.start_pos[1]),
-        )
-
-    def end(self):
-        if self.layer:
-            self.layer.camera.set_center(*self.stop_pos)
-        super().end()
-
-class GlideCameraTo(GlideCamera):
-    def __init__(
-        self,
-        stop: tuple[float, float],
-        duration: float = 1,
-        easing: bf.easing = bf.easing.EASE_IN_OUT,
-        scene_name: str | None = None,
-        layer_name: str = "world",
-    ):
-        super().__init__(
-            start=None,
-            stop=stop,
-            delta=None,
-            duration=duration,
-            easing=easing,
-            scene_name=scene_name,
-            layer_name=layer_name,
-        )
-        
-class GlideCameraBy(GlideCamera):
-    def __init__(
-        self,
-        delta: tuple[float, float],
-        duration: float = 1,
-        easing: bf.easing = bf.easing.EASE_IN_OUT,
-        scene_name: str | None = None,
-        layer_name: str = "world",
-    ):
-        super().__init__(
-            start=None,
-            stop=None,
-            delta=delta,
-            duration=duration,
-            easing=easing,
-            scene_name=scene_name,
-            layer_name=layer_name,
-        )

batFramework/cutsceneBlocks.py

@@ -0,0 +1,176 @@
+import batFramework as bf
+from .cutscene import Cutscene,CutsceneManager
+
+
+# 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.
+    """
+
+    # 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
+
+    # 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:
+            block.start()
+
+    # 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)
+
+
+# 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, duration, **kwargs) -> 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
+        # Timer to handle the end of the transition
+        self.timer = bf.Timer(name = "scene_transition_block",duration=duration, end_callback=self.end)
+
+    # Start the scene transition block
+    def start(self):
+        """
+        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:
+            self.end()
+            return
+        CutsceneManager().manager.transition_to_scene(
+            self.target_scene, self.transition, duration=self.duration, **self.kwargs
+        )
+        # Start the timer to handle the end of the transition
+        self.timer.start()
+
+    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,29 +2,22 @@ import pygame
 import batFramework as bf
 from typing import Self
 
-
 class DynamicEntity(bf.Entity):
     def __init__(
         self,
-        *args,**kwargs
+        size : None|tuple[int,int]=None,
+        no_surface : bool   =False,
+        surface_flags : int =0,
+        convert_alpha : bool=False
     ) -> None:
-        super().__init__(*args,**kwargs)
+        super().__init__(size,no_surface,surface_flags,convert_alpha)
         self.velocity = pygame.math.Vector2(0, 0)
-        self.ignore_collisions : bool = False
 
-    def on_collideX(self, collider: "DynamicEntity"):
-        """
-        Return true if collision
-        """
+    def on_collideX(self, collider: Self):
         return False
 
-    def on_collideY(self, collider: "DynamicEntity"):
-        """
-        Return true if collision
-        """
+    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