batframework 1.0.8a12__py3-none-any.whl → 1.0.8a14__py3-none-any.whl

batFramework/__init__.py

@@ -8,7 +8,7 @@ from .resourceManager import ResourceManager
 from .fontManager import FontManager
 from .utils import Utils as utils
 from .tileset import Tileset
-from .time import *
+from .timeManager import TimeManager,Timer,SceneTimer
 from .easingController import EasingController
 from .cutscene import Cutscene, CutsceneManager
 from .cutsceneBlocks import *
@@ -17,14 +17,15 @@ import batFramework.transition as transition
 from .action import Action
 from .actionContainer import *
 from .camera import Camera
-from .object import Object
 from .entity import Entity
+from .drawable import Drawable
 from .renderGroup import RenderGroup
 from .dynamicEntity import DynamicEntity
 from .sprite import Sprite
 from .scrollingSprite import ScrollingSprite
 from .particle import *
-from .animatedSprite import AnimatedSprite, Animation
+from .animation import Animation
+from .animatedSprite import AnimatedSprite
 from .character import Character
 from .stateMachine import State, StateMachine
 from .scene import Scene

batFramework/animatedSprite.py

@@ -1,59 +1,11 @@
 import batFramework as bf
 import pygame
 from typing import List, Dict, Tuple, Union, Optional, Self
+from .animation import Animation
 
-
-def search_index(target: int, lst: List[int]) -> int:
-    cumulative_sum = 0
-    for index, value in enumerate(lst):
-        cumulative_sum += value
-        if cumulative_sum >= target:
-            return index
-    return -1
-
-
-class Animation:
-    def __init__(
-        self,
-        name: str
-    ) -> None:
-        self.name = name
-        self.frames: list[pygame.Surface] = []
-        self.frames_flipX : list[pygame.Surface] = []
-        self.duration_list = []
-        self.duration_list_length = 1
-
-    def from_surface(self,surface:pygame.Surface,size : Tuple[int,int])->Self:
-        self.frames         : List[pygame.Surface] = list(bf.utils.split_surface(surface, size).values())
-        self.frames_flipX   : List[pygame.Surface] = list(bf.utils.split_surface(surface, size,func=lambda s : pygame.transform.flip(s,True,False)).values())
-        return self
-
-    def __repr__(self):
-        return f"Animation({self.name})"
-
-    def counter_to_frame(self, counter: Union[float, int]) -> int:
-        if not self.frames : 
-            raise ValueError("Animation has no frames")
-        return search_index(
-            int(counter % self.duration_list_length), self.duration_list
-        )
-
-    def get_frame(self, counter: Union[float, int], flip: bool) -> pygame.Surface:
-        i = self.counter_to_frame(counter)
-        return self.frames_flipX[i] if flip else self.frames[i]
-
-    def set_duration_list(self, duration_list: Union[List[int], int]) -> Self:
-        if isinstance(duration_list, int):
-            duration_list = [duration_list] * len(self.frames)
-        if len(duration_list) != len(self.frames):
-            raise ValueError("duration_list should have values for all frames")
-        self.duration_list = duration_list
-        self.duration_list_length = sum(self.duration_list)
-        return self
-
-class AnimatedSprite(bf.Entity):
-    def __init__(self, size: Optional[Tuple[int, int]] = None) -> None:
-        super().__init__(size, no_surface=True)
+class AnimatedSprite(bf.Drawable):
+    def __init__(self, size: Optional[Tuple[int, int]] = None,*args,**kwargs) -> None:
+        super().__init__(size, no_surface=True,*args,**kwargs)
         self.float_counter: float = 0
         self.animations: Dict[str, Animation] = {}
         self.current_state: Optional[Animation] = None

batFramework/animation.py

@@ -0,0 +1,52 @@
+import pygame
+import batFramework as bf
+from typing import List, Dict, Tuple, Union, Optional, Self
+
+
+def search_index(target: int, lst: List[int]) -> int:
+    cumulative_sum = 0
+    for index, value in enumerate(lst):
+        cumulative_sum += value
+        if cumulative_sum >= target:
+            return index
+    return -1
+
+
+class Animation:
+    def __init__(
+        self,
+        name: str
+    ) -> None:
+        self.name = name
+        self.frames: list[pygame.Surface] = []
+        self.frames_flipX : list[pygame.Surface] = []
+        self.duration_list = []
+        self.duration_list_length = 1
+
+    def from_surface(self,surface:pygame.Surface,size : Tuple[int,int])->Self:
+        self.frames         : List[pygame.Surface] = list(bf.utils.split_surface(surface, size).values())
+        self.frames_flipX   : List[pygame.Surface] = list(bf.utils.split_surface(surface, size,func=lambda s : pygame.transform.flip(s,True,False)).values())
+        return self
+
+    def __repr__(self):
+        return f"Animation({self.name})"
+
+    def counter_to_frame(self, counter: Union[float, int]) -> int:
+        if not self.frames : 
+            raise ValueError("Animation has no frames")
+        return search_index(
+            int(counter % self.duration_list_length), self.duration_list
+        )
+
+    def get_frame(self, counter: Union[float, int], flip: bool) -> pygame.Surface:
+        i = self.counter_to_frame(counter)
+        return self.frames_flipX[i] if flip else self.frames[i]
+
+    def set_duration_list(self, duration_list: Union[List[int], int]) -> Self:
+        if isinstance(duration_list, int):
+            duration_list = [duration_list] * len(self.frames)
+        if len(duration_list) != len(self.frames):
+            raise ValueError("duration_list should have values for all frames")
+        self.duration_list = duration_list
+        self.duration_list_length = sum(self.duration_list)
+        return self

batFramework/character.py

@@ -3,9 +3,9 @@ from .stateMachine import State
 from .animatedSprite import AnimatedSprite
 from .dynamicEntity import DynamicEntity
 
-class Character(AnimatedSprite,DynamicEntity):
-    def __init__(self) -> None:
-        super().__init__()
+class Character(DynamicEntity,AnimatedSprite):
+    def __init__(self,*args,**kwargs) -> None:
+        super().__init__(*args,**kwargs)
         self.state_machine = bf.StateMachine(self)
         self.do_setup_animations()
         self.do_setup_states()

batFramework/constants.py

@@ -4,6 +4,8 @@ import pygame
 class Constants:
     SCREEN: pygame.Surface = None
     RESOLUTION: tuple[int, int] = (1280, 720)
+    WIDTH = 1280
+    HEIGHT = 720
     VSYNC = 0
     FLAGS: int = pygame.SCALED | pygame.RESIZABLE
     FPS: int = 60
@@ -18,6 +20,8 @@ class Constants:
     @staticmethod
     def set_resolution(resolution: tuple[int, int]):
         Constants.RESOLUTION = resolution
+        Constants.WIDTH = resolution[0]
+        Constants.HEIGHT = resolution[1]
 
     @staticmethod
     def set_default_cursor(cursor: pygame.Cursor):

batFramework/cutscene.py

@@ -1,5 +1,5 @@
 import batFramework as bf
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING,Self
 
 class CutsceneBlock: ...
 
@@ -75,13 +75,15 @@ class Cutscene:
     def init_blocks(self):
         pass
 
-    def add_blocks(self, *blocks: CutsceneBlock):
+    def add_blocks(self, *blocks: CutsceneBlock)->Self:
         self.cutscene_blocks.extend(blocks)
-
-    def add_end_blocks(self, *blocks: CutsceneBlock):
+        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]
 

batFramework/drawable.py

@@ -0,0 +1,75 @@
+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, int] = None,
+        surface_flags: int = 0,
+        convert_alpha: bool = False,
+        *args,
+        **kwargs,
+    ) -> None:
+        super().__init__()
+        self.visible: bool = True
+        self.render_order: int = 0
+        self.rect.size = (10, 10) if size is None else size
+        self.convert_alpha: bool = convert_alpha
+        self.surface_flags: int = surface_flags
+        self.blit_flags: int = 0
+        self.surface: pygame.Surface = pygame.Surface(self.rect.size, surface_flags)
+        if convert_alpha:
+            self.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_scene:
+            self.parent_scene.sort_entities()
+        return self
+
+    def set_visible(self, value: bool) -> Self:
+        self.visible = value
+        return self
+
+    def draw(self, camera: bf.Camera) -> None:
+        """
+        Draw the entity onto the camera surface
+        """
+        if not self.visible or not camera.rect.colliderect(self.rect):
+            return
+        camera.surface.blit(
+            self.surface,
+            camera.world_to_screen(self.rect),
+            special_flags=self.blit_flags,
+        )

batFramework/entity.py

@@ -1,74 +1,124 @@
 from typing import Any, Self
 import pygame
 import batFramework as bf
-from .object import Object
-
-
-class Entity(Object):
-    """
-    Basic entity class
-    """
-
-    def __init__(
-        self,
-        size: None | tuple[int, int] = None,
-        surface_flags: int = 0,
-        convert_alpha: bool = False,
-        *args,
-        **kwargs,
-    ) -> None:
-        super().__init__()
-        self.visible: bool = True
-        self.rect.size = (10, 10) if size is None else size
-        self.convert_alpha: bool = convert_alpha
-        self.surface_flags: int = surface_flags
-        self.blit_flags: int = 0
-        self.surface: pygame.Surface = pygame.Surface(self.rect.size, surface_flags)
-        if convert_alpha:
-            self.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
+from typing import TYPE_CHECKING
 
-    def get_alpha(self) -> int:
-        return self.surface.get_alpha()
+if TYPE_CHECKING:
+    from .camera import Camera
 
-    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
+class Entity:
+    __count = 0
+    __available_uid = set()
+    __used_uid = set()
+
+    def __init__(self) -> None:
+        self.rect = pygame.FRect(0, 0, 0, 0)
+        self.tags: list[str] = []
+        self.parent_scene: bf.Scene | None = None
+        self.debug_color: tuple | str = "red"
+        self.uid: int = Entity.__count
+        Entity.__used_uid.add(self.uid)
+
+        if Entity.__available_uid:
+            self.name = Entity.__available_uid.pop()
+        else:
+            self.name = Entity.__count
+            Entity.__count += 1
+
+    def __del__(self):
+        Entity.__available_uid.add(self.uid)
+
+    def set_position(self, x, y) -> Self:
+        self.rect.topleft = x, y
         return self
 
-    def set_blit_flags(self, blit_flags: int) -> Self:
-        self.blit_flags = blit_flags
+    def set_center(self, x, y) -> Self:
+        self.rect.center = x, y
         return self
 
     def get_debug_outlines(self):
-        if self.visible:
-            yield (self.rect, self.debug_color)
+        yield (self.rect, self.debug_color)
 
-    def set_render_order(self, render_order: int) -> Self:
-        self.render_order = render_order
-        if self.parent_scene:
-            self.parent_scene.sort_entities()
+    def set_debug_color(self, color) -> Self:
+        self.debug_color = color
         return self
 
-    def set_visible(self, value: bool) -> Self:
-        self.visible = value
+    def set_parent_scene(self, scene) -> Self:
+        if scene == self.parent_scene:
+            return self
+        if self.parent_scene is not None:
+            self.do_when_removed()
+        self.parent_scene = scene
+        if scene is not None:
+            self.do_when_added()
         return self
 
-    def draw(self, camera: bf.Camera) -> None:
+    def do_when_added(self):
+        pass
+
+    def do_when_removed(self):
+        pass
+
+    def set_uid(self, uid: int) -> Self:
+        if uid in Entity.__used_uid:
+            print(f"set_uid error : UID '{uid}' is already in use")
+            return self
+        self.uid = uid
+        if uid in Entity.__used_uid:
+            Entity.__used_uid.remove(uid)
+        Entity.__used_uid.add(uid)
+        return self
+
+    def add_tags(self, *tags) -> Self:
+        for tag in tags:
+            if tag not in self.tags:
+                self.tags.append(tag)
+        self.tags.sort()
+        return self
+
+    def remove_tags(self, *tags):
+        self.tags = [tag for tag in self.tags if tag not in tags]
+
+    def has_tags(self, *tags) -> bool:
+        return all(tag in self.tags for tag in tags)
+
+    def get_tags(self) -> list[str]:
+        return self.tags
+
+    def process_event(self, event: pygame.Event) -> bool:
         """
-        Draw the entity onto the camera surface
+        Returns bool : True if the method is blocking (no propagation to next Entity of the scene)
         """
-        if not self.visible or not camera.rect.colliderect(self.rect):
+        if event.consumed:
             return
-        camera.surface.blit(
-            self.surface,
-            camera.world_to_screen(self.rect),
-            special_flags=self.blit_flags,
-        )
+        self.do_process_actions(event)
+        self.do_handle_event(event)
+
+    def do_process_actions(self, event: pygame.Event) -> None:
+        """
+        Process entity actions you may have set
+        """
+
+    def do_reset_actions(self) -> None:
+        """
+        Reset entity actions you may have set
+        """
+
+    def do_handle_event(self, event: pygame.Event):
+        """
+        Handle specific events with no action support
+        """
+        return False
+
+    def update(self, dt: float) -> None:
+        """
+        Update method to be overriden by subclasses of Entity (must call do_update and do_reset_actions)
+        """
+        self.do_update(dt)
+        self.do_reset_actions()
+
+    def do_update(self, dt: float) -> None:
+        """
+        Update method to be overriden for specific behavior by the end user
+        """

batFramework/gui/container.py

@@ -174,7 +174,7 @@ class Container(Shape, InteractiveWidget):
             self.paint()
             self.dirty_surface = False
 
-        bf.Entity.draw(self, camera)
+        bf.Drawable.draw(self, camera)
 
         if self.clip_children:
             new_clip = camera.world_to_screen(self.get_padded_rect())

batFramework/gui/debugger.py

@@ -72,7 +72,7 @@ class Debugger(Label):
     def update(self, dt: float) -> None:
         if not self.parent_scene:
             return
-        if self.parent_scene.get_sharedVar("debug_mode") != bf.debugMode.DEBUGGER:
+        if bf.ResourceManager().get_sharedVar("debug_mode") != bf.debugMode.DEBUGGER:
             self.set_visible(False)
             return
         self.set_visible(True)

batFramework/gui/label.py

@@ -37,7 +37,6 @@ class Label(Shape):
         self.text_rect = pygame.FRect(0, 0, 0, 0)
         # text surface (result of font.render)
         self.text_surface: pygame.Surface = pygame.Surface((0, 0))
-        self.do_caching: bool = False
 
         self.show_text_outline: bool = False
 
@@ -54,21 +53,9 @@ class Label(Shape):
         self.set_autoresize(True)
         self.set_font(force=True)
 
-    @staticmethod
-    def clear_cache():
-        Label._text_cache = {}
-
     def __str__(self) -> str:
         return f"Label({repr(self.text)})"
 
-    def enable_caching(self) -> Self:
-        self.do_caching = True
-        return self
-
-    def disable_caching(self) -> Self:
-        self.do_caching = False
-        return self
-
     def set_text_color(self, color) -> Self:
         self.text_color = color
         self.dirty_surface = True
@@ -197,7 +184,6 @@ class Label(Shape):
             self.text_rect.size = self._get_text_rect_required_size()
         res = self.inflate_rect_by_padding((0, 0, *self.text_rect.size)).size
 
-        return res
         return res[0] if self.autoresize_w else self.rect.w, (
             res[1] if self.autoresize_h else self.rect.h
         )
@@ -206,35 +192,26 @@ class Label(Shape):
         return self.text
 
     def _render_font(self, params: dict) -> pygame.Surface:
-        key = tuple(params.values())
-
-        cached_value = Label._text_cache.get(key, None)
 
         if self.draw_mode == bf.drawMode.SOLID:
-            if cached_value is None:
-                params.pop("font_name")
-
-                # save old settings
-                old_italic = self.font_object.get_italic()
-                old_bold = self.font_object.get_bold()
-                old_underline = self.font_object.get_underline()
-
-                # setup font
-                self.font_object.set_italic(self.is_italic)
-                self.font_object.set_bold(self.is_bold)
-                self.font_object.set_underline(self.is_underlined)
-
-                surf = self.font_object.render(**params)
-
-                # reset font
-                self.font_object.set_italic(old_italic)
-                self.font_object.set_bold(old_bold)
-                self.font_object.set_underline(old_underline)
-
-                if self.do_caching:
-                    Label._text_cache[key] = surf
-            else:
-                surf = cached_value
+            params.pop("font_name")
+
+            # save old settings
+            old_italic = self.font_object.get_italic()
+            old_bold = self.font_object.get_bold()
+            old_underline = self.font_object.get_underline()
+
+            # setup font
+            self.font_object.set_italic(self.is_italic)
+            self.font_object.set_bold(self.is_bold)
+            self.font_object.set_underline(self.is_underlined)
+
+            surf = self.font_object.render(**params)
+
+            # reset font
+            self.font_object.set_italic(old_italic)
+            self.font_object.set_bold(old_bold)
+            self.font_object.set_underline(old_underline)
         else:
             params.pop("font_name")
             surf = self.font_object.render(**params)

batFramework/gui/layout.py

@@ -1,8 +1,8 @@
 import batFramework as bf
 from .widget import Widget
 from .constraints.constraints import *
-from typing import Self, TYPE_CHECKING,override
-from abc import ABC,abstractmethod
+from typing import Self, TYPE_CHECKING
+from abc import ABC
 import pygame
 
 if TYPE_CHECKING:

batFramework/gui/root.py

@@ -95,8 +95,6 @@ class Root(InteractiveWidget):
         return self
 
     def do_handle_event(self, event):
-        if not self.parent_scene.get_sharedVar("player_has_control"):
-            return
         if self.focused:
             if event.type == pygame.KEYDOWN:
                 if self.focused.on_key_down(event.key):
@@ -130,8 +128,6 @@ class Root(InteractiveWidget):
 
     def update(self, dt: float) -> None:
         super().update(dt)
-        if not self.parent_scene.get_sharedVar("player_has_control",True):
-            return
         old = self.hovered
         transposed = self.drawing_camera.screen_to_world(pygame.mouse.get_pos())
         self.hovered = self.top_at(*transposed) if self.top_at(*transposed) else None
@@ -145,8 +141,6 @@ class Root(InteractiveWidget):
 
     def draw(self, camera: bf.Camera) -> None:
         super().draw(camera)
-        if not self.parent_scene.get_sharedVar("player_has_control"):
-            return
         if (
             self.parent_scene
             and self.parent_scene.active

batFramework/gui/widget.py

@@ -18,7 +18,7 @@ class WidgetMeta(type):
         return obj
 
 
-class Widget(bf.Entity, metaclass=WidgetMeta):
+class Widget(bf.Drawable, metaclass=WidgetMeta):
     def __init__(self, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
         self.children: list["Widget"] = []