batframework 1.0.9a7__py3-none-any.whl → 1.0.9a9__py3-none-any.whl

batFramework/cutscene.py

@@ -1,42 +1,92 @@
 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 end(self):
+        """
+        Mark self as over
+        """
+        self.is_over = True
+
+class Sequence(Cutscene):
     def __init__(self,*cutscenes):
-        self.is_over : bool = False
-        self.sub_cutscenes : list[Cutscene] = list(cutscenes)
-        self.sub_index = -1
+        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_index = 0
-            self.sub_cutscenes[self.sub_index].start()
-        else:
-            self.end()
+            self.sub_cutscenes[0].start()
 
     def process_event(self,event):
-        if self.sub_index > 0: 
-            self.sub_cutscenes[self.sub_index].process_event(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):
-        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):
+        """
+        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.sub_index].start()
-            
-    def end(self):
-        self.is_over = True
+                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"):
-        super().__init__()
         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()
 
@@ -44,10 +94,160 @@ class Wait(Cutscene):
 
 class TransitionToScene(Cutscene):
     def __init__(self,scene_name:str,transition:Transition):
-        super().__init__()
         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/cutsceneManager.py

@@ -9,7 +9,7 @@ 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
 
@@ -21,11 +21,14 @@ class CutsceneManager(metaclass=bf.Singleton):
 
     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

@@ -11,7 +11,7 @@ class Drawable(Entity):
 
     def __init__(
         self,
-        size: None | tuple[int, int] = None,
+        size: None | tuple[int|float] = None,
         surface_flags: int = 0,
         convert_alpha: bool = False,
         *args,
@@ -20,10 +20,12 @@ class Drawable(Entity):
         super().__init__()
         self.visible: bool = True
         self.render_order: int = 0
-        self.rect.size = (10, 10) if size is None else size
+        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()
@@ -54,8 +56,8 @@ class Drawable(Entity):
 
     def set_render_order(self, render_order: int) -> Self:
         self.render_order = render_order
-        if self.parent_scene:
-            self.parent_scene.sort_entities()
+        if self.parent_layer:
+            self.parent_layer.update_draw_order()
         return self
 
     def set_visible(self, value: bool) -> Self:
@@ -66,7 +68,7 @@ class Drawable(Entity):
         """
         Draw the entity onto the camera surface
         """
-        if not self.visible or not camera.rect.colliderect(self.rect) or self.surface.get_alpha() == 0:
+        if not self.visible or self.drawn_by_group or not camera.rect.colliderect(self.rect) or self.surface.get_alpha() == 0:
             return
         camera.surface.blit(
             self.surface,

batFramework/easingController.py

@@ -1,7 +1,6 @@
 import pygame
 import batFramework as bf
 from functools import lru_cache
-from .enums import easing
 from typing import Callable,Any
 
 
@@ -20,16 +19,17 @@ def process_value(progress: float, p0: float, p1: float, p2: float, p3: float) -
 class EasingController(bf.Timer):
     def __init__(
         self,
-        easing_function: easing = easing.LINEAR,
         duration: float = 1,
+        easing: bf.easing = bf.easing.LINEAR,
         update_callback=None,
-        end_callback: Callable[[],Any]=None,
-        loop: bool = False,
+        end_callback: Callable[[], Any] = None,
+        loop: int = 0,
+        register:str="global"
     ) -> None:
-        self.easing_function = easing_function
-        self.update_callback: Callable[[float],Any] = update_callback
+        self.easing_function = easing
+        self.update_callback: Callable[[float], Any] = update_callback
         self.value: float = 0.0
-        super().__init__(duration, end_callback, loop)
+        super().__init__(duration, end_callback, loop, register)
 
     def get_value(self) -> float:
         return self.value
@@ -44,12 +44,11 @@ class EasingController(bf.Timer):
         super().update(dt)
         if self.get_progression() == 0:
             return
-        if self.easing_function == easing.LINEAR:
+        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
-            )
+            self.value = process_value(self.get_progression(), *self.easing_function.control_points)
+        
         if self.update_callback:
             self.update_callback(self.value)
 

batFramework/entity.py

@@ -11,7 +11,6 @@ class Entity:
     _count: int = 0
     _available_uids: set[int] = set()
 
-
     def __init__(self,*args,**kwargs) -> None:
         if Entity._available_uids:
             self.uid = Entity._available_uids.pop()
@@ -19,9 +18,10 @@ class Entity:
             self.uid = Entity._count
             Entity._count += 1
 
-        self.rect = pygame.FRect(0, 0, 0, 0)
+        self.rect = pygame.FRect(0, 0, 10, 10)
         self.tags: list[str] = []
         self.parent_scene: bf.Scene | None = None
+        self.parent_layer: bf.SceneLayer | None = None
         self.debug_color: tuple | str = "red"
 
     def __del__(self):
@@ -44,6 +44,16 @@ class Entity:
         self.debug_color = color
         return self
 
+    def kill(self):
+        """
+        Removes the entity from a scene layer
+        """
+        if self.parent_layer:
+            self.parent_layer.remove(self)
+
+    def set_parent_layer(self, layer):
+        self.parent_layer = layer
+
     def set_parent_scene(self, scene) -> Self:
         if scene == self.parent_scene:
             return self
@@ -71,8 +81,17 @@ class Entity:
         self.tags = [tag for tag in self.tags if tag not in tags]
 
     def has_tags(self, *tags) -> bool:
+        """
+        return True if entity contains all given tags
+        """
         return all(tag in self.tags for tag in tags)
 
+    def has_any_tags(self, *tags) -> bool:
+        """
+        return True if entity contains any of given tags
+        """
+        return any(tag in self.tags for tag in tags)
+
     def get_tags(self) -> list[str]:
         return self.tags
 

batFramework/enums.py

@@ -3,52 +3,58 @@ import pygame
 
 playerInput = [pygame.KEYDOWN,pygame.MOUSEBUTTONDOWN,pygame.KEYUP,pygame.MOUSEBUTTONUP]
 
-
-
 class color:
-    WHITE = (255, 255, 255)
-    LIGHTER_GRAY = (236, 240, 241)
-    LIGHT_GRAY = (189, 195, 199)
-    DARK_GRAY = (66, 66, 66)
-    DARKER_GRAY = (23, 23, 23)
-    BLACK = (0, 0, 0)
+    WHITE = pygame.Color(255, 255, 255)
+    LIGHTER_GRAY = pygame.Color(236, 240, 241)
+    LIGHT_GRAY = pygame.Color(189, 195, 199)
+    DARK_GRAY = pygame.Color(66, 66, 66)
+    DARKER_GRAY = pygame.Color(23, 23, 23)
+    BLACK = pygame.Color(0, 0, 0)
 
-    TURQUOISE = (26, 188, 156)
-    TURQUOISE_SHADE = (22, 160, 133)
+    TURQUOISE = pygame.Color(26, 188, 156)
+    TURQUOISE_SHADE = pygame.Color(22, 160, 133)
 
-    GREEN = (46, 204, 113)
-    GREEN_SHADE = (39, 174, 96)
+    GREEN = pygame.Color(46, 204, 113)
+    GREEN_SHADE = pygame.Color(39, 174, 96)
 
-    BLUE = (52, 152, 219)
-    BLUE_SHADE = (41, 128, 185)
+    BLUE = pygame.Color(52, 152, 219)
+    BLUE_SHADE = pygame.Color(41, 128, 185)
 
-    PURPLE = (155, 89, 182)
-    PURPLE_SHADE = (142, 68, 173)
+    PURPLE = pygame.Color(155, 89, 182)
+    PURPLE_SHADE = pygame.Color(142, 68, 173)
 
-    CHARCOAL = (52, 73, 94)
-    CHARCOAL_SHADE = (44, 62, 80)
+    CHARCOAL = pygame.Color(52, 73, 94)
+    CHARCOAL_SHADE = pygame.Color(44, 62, 80)
 
-    GOLD = (241, 196, 15)
-    GOLD_SHADE = (243, 156, 18)
+    GOLD = pygame.Color(241, 196, 15)
+    GOLD_SHADE = pygame.Color(243, 156, 18)
 
-    ORANGE = (230, 126, 34)
-    ORANGE_SHADE = (211, 84, 0)
+    ORANGE = pygame.Color(230, 126, 34)
+    ORANGE_SHADE = pygame.Color(211, 84, 0)
 
-    RED = (231, 76, 60)
-    RED_SHADE = (192, 57, 43)
+    RED = pygame.Color(231, 76, 60)
+    RED_SHADE = pygame.Color(192, 57, 43)
 
-    CLOUD = (236, 240, 241)
-    CLOUD_SHADE = (189, 195, 199)
+    CLOUD = pygame.Color(236, 240, 241)
+    CLOUD_SHADE = pygame.Color(189, 195, 199)
 
-    CONCRETE = (149, 165, 166)
-    CONCRETE_SHADE = (127, 140, 141)
+    CONCRETE = pygame.Color(149, 165, 166)
+    CONCRETE_SHADE = pygame.Color(127, 140, 141)
 
     # GB
-    DARKER_GB = (27, 42, 9)
-    DARK_GB = (14, 69, 11)
-    LIGHT_GB = (73, 107, 34)
-    LIGHTER_GB = (154, 158, 63)
-
+    DARKER_GB = pygame.Color(27, 42, 9)
+    DARK_GB = pygame.Color(14, 69, 11)
+    LIGHT_GB = pygame.Color(73, 107, 34)
+    LIGHTER_GB = pygame.Color(154, 158, 63)
+
+    @staticmethod
+    def mult(color: pygame.Color, factor: float):
+        return pygame.Color(
+            min(max(0, int(color.r * factor)), 255),
+            min(max(0, int(color.g * factor)), 255),
+            min(max(0, int(color.b * factor)), 255),
+            color.a
+        )
 
 class easing(Enum):
     LINEAR = (0, 0, 1, 1)
@@ -60,6 +66,13 @@ class easing(Enum):
     def __init__(self, *control_points):
         self.control_points = control_points
 
+    @classmethod
+    def create(cls, *control_points):
+        """Create a custom easing instance."""
+        instance = object.__new__(cls)  
+        instance._value_ = control_points
+        instance.control_points = control_points
+        return instance
 
 class axis(Enum):
     HORIZONTAL = "horizontal"
@@ -83,6 +96,8 @@ class alignment(Enum):
     TOPRIGHT = "topright"
     MIDLEFT = "midleft"
     MIDRIGHT = "midright"
+    MIDTOP = "midtop"
+    MIDBOTTOM = "midbottom"
     BOTTOMLEFT = "bottomleft"
     BOTTOMRIGHT = "bottomright"
 

batFramework/gui/__init__.py

@@ -7,8 +7,9 @@ from .draggableWidget import DraggableWidget
 from .clickableWidget import ClickableWidget
 from .root import Root
 from .shape import Shape
-from .meter import Meter
+from .meter import BarMeter
 from .label import Label
+from .tooltip import ToolTip
 from .animatedLabel import AnimatedLabel
 from .textInput import TextInput
 from .button import Button
@@ -17,6 +18,8 @@ from .layout import *
 from .container import Container
 from .indicator import *
 from .toggle import Toggle
-from .radioButton import RadioButton, RadioVariable
+from .syncedVar import SyncedVar
+from .radioButton import RadioButton
 from .slider import Slider
-from .constraints import *
+from .selector import Selector
+import batFramework.gui.constraints as constraints

batFramework/gui/animatedLabel.py

@@ -1,6 +1,6 @@
 from .label import Label
 import batFramework as bf
-from typing import Self
+from typing import Self,Callable,Any
 
 
 class AnimatedLabel(Label):
@@ -10,6 +10,7 @@ class AnimatedLabel(Label):
         self.is_over: bool = True
         self.is_paused: bool = False
         self.original_text = ""
+        self.end_callback : Callable[[],Any]= None
         self.set_autoresize(False)
         self.set_alignment(bf.alignment.LEFT)
         super().__init__("")
@@ -18,6 +19,9 @@ class AnimatedLabel(Label):
     def __str__(self) -> str:
         return "AnimatedLabel"
 
+    def set_end_callback(self,callback:Callable[[],Any]):
+        self.end_callback = callback
+
     def pause(self) -> Self:
         self.is_paused = True
         return self
@@ -31,7 +35,7 @@ class AnimatedLabel(Label):
         return self
 
     def cut_text_to_width(self, text: str) -> list[str]:
-        w = self.get_padded_width()
+        w = self.get_inner_width()
         if text == "" or not self.font_object or w < self.font_object.point_size:
             return [text]
         left = 0
@@ -72,7 +76,11 @@ class AnimatedLabel(Label):
         if self.is_over:
             return
         if not self.is_over and self.cursor_position == len(self.original_text):
+            if len(self.original_text) == 0:
+                self._set_text_internal("")
             self.is_over = True
+            if self.end_callback is not None:
+                self.end_callback()
             return
         self.cursor_position = min(
             self.cursor_position + self.text_speed * dt, len(self.original_text)

batFramework/gui/button.py

@@ -2,8 +2,6 @@ from .label import Label
 import batFramework as bf
 from typing import Self, Callable,Any
 from .clickableWidget import ClickableWidget
-import pygame
-from math import ceil
 
 
 class Button(Label, ClickableWidget):
@@ -12,34 +10,9 @@ class Button(Label, ClickableWidget):
         self.set_callback(callback)
 
     def __str__(self) -> str:
-        return f"Button({self.text})"
+        return f"Button('{self.text}')"
 
-    def get_min_required_size(self) -> tuple[float, float]:
-        if not (self.autoresize_w or self.autoresize_h):
-            return self.rect.size
-        if not self.text_rect:
-            self.text_rect.size = self._get_text_rect_required_size()
-        res = self.inflate_rect_by_padding((0, 0, *self.text_rect.size)).size
+    def get_min_required_size(self):
+        res = super().get_min_required_size()
         res = res[0],res[1]+self.unpressed_relief
-        return res[0] if self.autoresize_w else self.rect.w, (
-            res[1] if self.autoresize_h else self.rect.h
-        )
-
-
-    def _build_layout(self) -> None:
-
-        self.text_rect.size = self._get_text_rect_required_size()
-        if self.autoresize_h or self.autoresize_w:
-            target_rect = self.inflate_rect_by_padding((0, 0, *self.text_rect.size))
-            target_rect.h += self.unpressed_relief
-            if not self.autoresize_w:
-                target_rect.w = self.rect.w
-            if not self.autoresize_h:
-                target_rect.h = self.rect.h
-            if self.rect.size != target_rect.size:
-                self.set_size(target_rect.size)
-                self.apply_updates()
-                return
-        offset = self._get_outline_offset() if self.show_text_outline else (0,0)
-        padded = self.get_padded_rect().move(-self.rect.x + offset[0], -self.rect.y + offset[1])
-        self.align_text(self.text_rect, padded, self.alignment)
+        return res