batframework 1.0.10__py3-none-any.whl → 2.0.0a1__py3-none-any.whl

batFramework/cutscene.py

@@ -1,119 +1,239 @@
-import batFramework as bf
-
-
-class CutsceneBlock:
-    ...
-
-
-class Cutscene:
-    ...
-
-
-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 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 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
-                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
-
-
+import batFramework as bf
+from .transition import Transition
+from typing import Callable,Any
+
+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
+            
+    def update(self,dt):
+        pass
+
+    def __str__(self)->str:
+        return self.__class__.__name__
+
+    def end(self):
+        """
+        Mark self as over
+        """
+        print("Start ",self)
+
+        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()
+                    return
+                self.sub_cutscenes[self.index].start()
+
+
+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):
+        if not self.scene: 
+            self.end()
+            return
+        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,
+        stop: tuple[float, float] | None,
+        duration: float = 1,
+        easing: bf.easing = bf.easing.EASE_IN_OUT,
+        scene_name: str | None = None,
+        layer_name: str = "world",
+    ):
+        """
+        If start is None, it will be defaulted to the current camera center position.
+        Stop must be provided
+        """
+        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.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()
+
+        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 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",
+    ):
+        stop_pos = (
+            start_pos[0] + self.delta[0],
+            start_pos[1] + self.delta[1],
+        )
+        super().__init__(
+            start=None,
+            stop=None,
+            delta=delta,
+            duration=duration,
+            easing=easing,
+            scene_name=scene_name,
+            layer_name=layer_name,
+        )

batFramework/cutsceneManager.py

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

batFramework/drawable.py

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

batFramework/dynamicEntity.py

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

batFramework/easingController.py

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