batframework 1.0.8a13__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,8 +17,8 @@ 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

batFramework/animatedSprite.py

@@ -3,7 +3,7 @@ import pygame
 from typing import List, Dict, Tuple, Union, Optional, Self
 from .animation import Animation
 
-class AnimatedSprite(bf.Entity):
+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

batFramework/character.py

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

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
@@ -205,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/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"] = []

batFramework/manager.py

@@ -1,23 +1,24 @@
 import batFramework as bf
 import pygame
 import asyncio
-import random
 
 class Manager(bf.SceneManager):
     def __init__(self, *initial_scene_list) -> None:
-        # random.seed("random")
         super().__init__()
-        self._screen: pygame.Surface | None = bf.const.SCREEN
-        self._timeManager = bf.TimeManager()
-        self._cutsceneManager = bf.CutsceneManager()
-        self._cutsceneManager.set_manager(self)
-        self._clock: pygame.Clock = pygame.Clock()
-        self._is_async_running : bool = False
-        self._running = False
+        self.debug_mode: bf.enums.debugMode = bf.debugMode.HIDDEN
+        self.screen: pygame.Surface | None = bf.const.SCREEN
+        self.timeManager = bf.TimeManager()
+        self.cutsceneManager = bf.CutsceneManager()
+        self.cutsceneManager.set_manager(self)
+        self.clock: pygame.Clock = pygame.Clock()
+        self.is_async_running : bool = False
+        self.running = False
         pygame.mouse.set_cursor(bf.const.DEFAULT_CURSOR)
         self.do_pre_init()
         self.init_scenes(*initial_scene_list)
-        self.set_sharedVar("clock", self._clock)
+        bf.ResourceManager().set_sharedVar("clock", self.clock)
+        bf.ResourceManager().set_sharedVar("debug_mode", self.debug_mode)
+
         self.do_init()
 
     @staticmethod
@@ -39,14 +40,14 @@ class Manager(bf.SceneManager):
         print("=" * 50)
         
         # Print the timers information
-        print(self._timeManager)
+        print(self.timeManager)
         
         # End with a visual separator
         print("=" * 50 + "\n")
 
 
     def get_fps(self) -> float:
-        return self._clock.get_fps()
+        return self.clock.get_fps()
 
     def do_init(self) -> None:
         pass
@@ -55,67 +56,67 @@ class Manager(bf.SceneManager):
         pass
 
     def stop(self) -> None:
-        self._running = False
+        self.running = False
 
     async def run_async(self):
-        if self._running:
+        if self.running:
             print("Error : Already running")
             return
-        self._is_async_running = True
-        self._running = True
+        self.is_async_running = True
+        self.running = True
         dt: float = 0
-        while self._running:
+        while self.running:
             for event in pygame.event.get():
                 event.consumed = False
                 self.process_event(event)
                 if not event.consumed:
                     if event.type == pygame.QUIT:
-                        self._running = False
+                        self.running = False
                         break
                     if event.type == pygame.VIDEORESIZE and not (
                         bf.const.FLAGS & pygame.SCALED
                     ):
                         bf.const.set_resolution((event.w, event.h))
             # update
-            self._timeManager.update(dt)
-            self._cutsceneManager.update(dt)
+            self.timeManager.update(dt)
+            self.cutsceneManager.update(dt)
             self.update(dt)
             # render
-            self._screen.fill((0, 0, 0))
-            self.draw(self._screen)
+            self.screen.fill((0, 0, 0))
+            self.draw(self.screen)
             pygame.display.flip()
-            dt = self._clock.tick(bf.const.FPS) / 1000
+            dt = self.clock.tick(bf.const.FPS) / 1000
             # dt = min(dt, 0.02) dirty fix for dt being too high when window not focused for a long time
             await asyncio.sleep(0)
         pygame.quit()
 
 
     def run(self) -> None:
-        if self._running:
+        if self.running:
             print("Error : Already running")
             return
-        self._running = True
+        self.running = True
         dt: float = 0
-        while self._running:
+        while self.running:
             for event in pygame.event.get():
                 event.consumed = False
                 self.process_event(event)
                 if not event.consumed:
                     if event.type == pygame.QUIT:
-                        self._running = False
+                        self.running = False
                         break
                     if event.type == pygame.VIDEORESIZE and not (
                         bf.const.FLAGS & pygame.SCALED
                     ):
                         bf.const.set_resolution((event.w, event.h))
             # update
-            self._timeManager.update(dt)
-            self._cutsceneManager.update(dt)
+            self.timeManager.update(dt)
+            self.cutsceneManager.update(dt)
             self.update(dt)
             # render
-            self._screen.fill((0, 0, 0))
-            self.draw(self._screen)
+            self.screen.fill((0, 0, 0))
+            self.draw(self.screen)
             pygame.display.flip()
-            dt = self._clock.tick(bf.const.FPS) / 1000
+            dt = self.clock.tick(bf.const.FPS) / 1000
             # dt = min(dt, 0.02) dirty fix for dt being too high when window not focused for a long time
         pygame.quit()

batFramework/particle.py

@@ -78,7 +78,7 @@ class DirectionalParticle(BasicParticle):
         super().update_surface()
 
 
-class ParticleGenerator(bf.Entity):
+class ParticleGenerator(bf.Drawable):
     def __init__(self) -> None:
         super().__init__((0, 0))
         self.particles: list[Particle] = []

batFramework/scene.py

@@ -70,35 +70,6 @@ class Scene:
         """Get the scene index."""
         return self.scene_index
 
-    def set_sharedVar(self, name: str, value: Any) -> bool:
-        """
-        Set a shared variable in the manager.
-
-        Args:
-            name: Name of the shared variable.
-            value: Value to set.
-
-        Returns:
-            bool: True if setting was successful, False otherwise.
-        """
-        if not self.manager:
-            return False
-        return self.manager.set_sharedVar(name, value)
-
-    def get_sharedVar(self, name: str, error_value=None) -> Any:
-        """
-        Get a shared variable from the manager.
-
-        Args:
-            name: Name of the shared variable.
-
-        Returns:
-            Any: Value of the shared variable.
-        """
-        if not self.manager:
-            return error_value
-        return self.manager.get_sharedVar(name, error_value)
-
     def do_when_added(self):
         pass
 
@@ -277,7 +248,6 @@ class Scene:
         self.actions.reset()
         self.early_actions.reset()
 
-
         if self.entities_to_add:
             for e in self.entities_to_add:
                 self.world_entities[e] = None
@@ -337,7 +307,7 @@ class Scene:
 
     def _draw_camera(self, camera: bf.Camera, entity_list):
         _ = [entity.draw(camera) for entity in entity_list]
-        debugMode = self.manager.debug_mode
+        debugMode = bf.ResourceManager().get_sharedVar("debug_mode")
         # Draw outlines for world entities if required
         if debugMode == bf.debugMode.OUTLINES:
             [self.debug_entity(e, camera) for e in entity_list]
@@ -355,15 +325,12 @@ class Scene:
         self.set_active(True)
         self.set_visible(True)
         self.root.clear_hovered()
-        # self.root.clear_focused()
         self.root.build()
         bf.TimeManager().activate_register(self.name)
         self.do_on_enter()
-        # self.root.visit(lambda e : e.resolve_constraints())
 
     def on_exit(self):
         self.root.clear_hovered()
-        # self.root.clear_focused()
         self.set_active(False)
         self.set_visible(False)
         self.actions.hard_reset()

batFramework/sceneManager.py

@@ -2,7 +2,6 @@ import batFramework as bf
 import pygame
 from typing import Self
 
-
 def swap(lst, index1, index2):
     lst[index1], lst[index2] = lst[index2], lst[index1]
 
@@ -11,11 +10,6 @@ class SceneManager:
     def __init__(self) -> None:
         self.scenes: list[bf.Scene] = []
         self.shared_events = {pygame.WINDOWRESIZED}
-
-        self.set_sharedVar("in_cutscene", False)
-        self.set_sharedVar("player_has_control", True)
-        self.old_player_control = True
-        self.debug_mode: bf.enums.debugMode = bf.debugMode.HIDDEN
         self.current_transitions: dict[str, bf.transition.Transition] = {}
 
     def init_scenes(self, *initial_scenes:bf.Scene):
@@ -23,7 +17,6 @@ class SceneManager:
             s.set_scene_index(index)
         for s in reversed(initial_scenes):
             self.add_scene(s)
-        # self.scenes = list(initial_scenes)
         self.set_scene(initial_scenes[0].get_name())
         self.update_scene_states()
 
@@ -38,7 +31,7 @@ class SceneManager:
         Print detailed information about the current state of the scenes and shared variables.
         """
 
-        def format_scene_info(scene):
+        def format_scene_info(scene:bf.Scene):
             status = 'Active' if scene.active else 'Inactive'
             visibility = 'Visible' if scene.visible else 'Invisible'
             return f"{scene.name:<30} | {status:<8} | {visibility:<10} | Index={scene.scene_index}"
@@ -78,13 +71,6 @@ class SceneManager:
 
         print("=" * 50 + "\n")
 
-
-    def set_sharedVar(self, name, value) -> None:
-        bf.ResourceManager().set_sharedVar(name,value)
-
-    def get_sharedVar(self, name, error_value=None):
-        return bf.ResourceManager().get_sharedVar(name, error_value)
-
     def get_current_scene_name(self) -> str:
         """get the name of the current scene"""
         return self.scenes[0].get_name()
@@ -106,10 +92,10 @@ class SceneManager:
     def remove_scene(self, name: str):
         self.scenes = [s for s in self.scenes if s.name != name]
 
-    def has_scene(self, name):
+    def has_scene(self, name:str):
         return any(name == scene.name for scene in self.scenes)
 
-    def get_scene(self, name):
+    def get_scene(self, name:str):
         if not self.has_scene(name):
             return None
         for scene in self.scenes:
@@ -150,8 +136,6 @@ class SceneManager:
     def _start_transition(self, target_scene: bf.Scene):
         target_scene.set_active(True)
         target_scene.set_visible(True)
-        self.old_player_control = bool(self.get_sharedVar("player_has_control"))
-        self.set_sharedVar("player_has_control", False)
 
     def _end_transition(self, scene_name, index):
         self.set_scene(scene_name, index, True)
@@ -177,11 +161,10 @@ class SceneManager:
             self.scenes[index].do_on_enter_early()
         target_scene.on_enter()
 
-        self.set_sharedVar("player_has_control", self.old_player_control)
 
 
     def cycle_debug_mode(self):
-        current_index = self.debug_mode.value
+        current_index = bf.ResourceManager().get_sharedVar("debug_mode").value
         next_index = (current_index + 1) % len(bf.debugMode)
         return bf.debugMode(next_index)
 
@@ -193,8 +176,7 @@ class SceneManager:
             and event.type == pygame.KEYDOWN
         ):
             if event.key == pygame.K_d:
-                self.debug_mode = self.cycle_debug_mode()
-                self.set_sharedVar("debug_mode", self.debug_mode)
+                bf.ResourceManager().set_sharedVar("debug_mode", self.cycle_debug_mode())
                 return
             if event.key == pygame.K_p:
                 self.print_status()

batFramework/sprite.py

@@ -3,11 +3,11 @@ import pygame
 from typing import Self
 
 
-class Sprite(bf.Entity):
+class Sprite(bf.Drawable):
     def __init__(
         self,
-        path=None,
         size: None | tuple[int, int] = None,
+        path=None,
         convert_alpha: bool = True,
     ):
         self.original_surface: pygame.Surface = None

batFramework/{time.py → timeManager.py}

@@ -1,7 +1,5 @@
 import batFramework as bf
 from typing import Self
-
-
 from typing import Callable, Union, Self
 
 

batFramework/utils.py

@@ -1,17 +1,16 @@
 import pygame
-from enum import Enum
-import os
 import batFramework as bf
-import json
+import random
 from .enums import *
 import re
-from typing import Callable, TYPE_CHECKING, Any
+from typing import Callable, TYPE_CHECKING
 from functools import cache
 if TYPE_CHECKING:
-    from .object import Object
+    from .drawable import Drawable
     from .entity import Entity
 
 
+
 class Singleton(type):
     _instances = {}
 
@@ -28,9 +27,15 @@ class Utils:
         surface: pygame.Surface, split_size: tuple[int, int], func=None
     ) -> dict[tuple[int, int], pygame.Surface]:
         """
-        Splits a surface into subsurfaces and returns a dictionnary of them
-        with their tuple coordinates as keys.
-        Exemple : '(0,0) : Surface'
+        Splits a surface into subsurfaces based on a given size and returns a dictionary of them with their coordinates as keys.
+
+        Args:
+            surface (pygame.Surface): The surface to be split.
+            split_size (tuple[int, int]): The size of each subsurface (width, height).
+            func (callable, optional): A function to apply to each subsurface. Defaults to None.
+
+        Returns:
+            dict[tuple[int, int], pygame.Surface]: A dictionary with (x, y) coordinates as keys and the corresponding subsurfaces as values.
         """
         width, height = surface.get_size()
         res = {}
@@ -47,6 +52,19 @@ class Utils:
 
     @staticmethod
     def filter_text(text_mode: textMode):
+        """
+        Filters a string based on the specified text mode.
+
+        Args:
+            text_mode (textMode): Mode specifying the type of filtering (ALPHABETICAL, NUMERICAL, ALPHANUMERICAL).
+
+        Returns:
+            callable: A function that takes a string and removes all characters not allowed by the text mode.
+
+        Raises:
+            ValueError: If an unsupported text mode is provided.
+        """
+
         if text_mode == textMode.ALPHABETICAL:
             pattern = re.compile(r"[^a-zA-Z]")
         elif text_mode == textMode.NUMERICAL:
@@ -66,15 +84,20 @@ class Utils:
     @cache
     def create_spotlight(inside_color, outside_color, radius, radius_stop=None, dest_surf=None,size=None):
         """
-        Draws a circle spotlight centered on a surface
-        inner color on the center
-        gradient towards outside color from radius to radius stop
-        surface background is made transparent
-        if des_surf is None:
-            if size is None :  size is radius_stop*radius_stop
-            returns the newly created surface of size 'size' with the spotlight drawn
-
+        Creates a spotlight effect on a surface with a gradient from inside_color to outside_color.
+
+        Args:
+            inside_color (tuple[int, int, int]): RGB color at the center of the spotlight.
+            outside_color (tuple[int, int, int]): RGB color at the outer edge of the spotlight.
+            radius (int): Radius of the inner circle.
+            radius_stop (int, optional): Radius where the spotlight ends. Defaults to the value of radius.
+            dest_surf (pygame.Surface, optional): Surface to draw the spotlight on. Defaults to None.
+            size (tuple[int, int], optional): Size of the surface if dest_surf is None. Defaults to a square based on radius_stop.
+
+        Returns:
+            pygame.Surface: The surface with the spotlight effect drawn on it.
         """
+
         if radius_stop is None:
             radius_stop = radius
         diameter = radius_stop * 2
@@ -103,6 +126,18 @@ class Utils:
 
     @staticmethod
     def draw_spotlight(dest_surf:pygame.Surface,inside_color,outside_color,radius,radius_stop=None,center=None):
+        """
+        Draws a spotlight effect directly onto an existing surface.
+
+        Args:
+            dest_surf (pygame.Surface): The surface to draw the spotlight on.
+            inside_color (tuple[int, int, int]): RGB color at the center of the spotlight.
+            outside_color (tuple[int, int, int]): RGB color at the outer edge of the spotlight.
+            radius (int): Radius of the inner circle.
+            radius_stop (int, optional): Radius where the spotlight ends. Defaults to the value of radius.
+            center (tuple[int, int], optional): Center point of the spotlight. Defaults to the center of dest_surf.
+        """
+
         if radius_stop is None:
             radius_stop = radius
         center = dest_surf.get_rect().center if center is None else center
@@ -117,12 +152,34 @@ class Utils:
             pygame.draw.circle(dest_surf, inside_color, center, radius)
 
     @staticmethod
-    def animate_move(entity:"Object", start_pos : tuple[float,float], end_pos:tuple[float,float])->Callable[[float],None]:
+    def animate_move(entity:"Entity", start_pos : tuple[float,float], end_pos:tuple[float,float])->Callable[[float],None]:
+        """
+        Creates a function to animate the movement of an entity from start_pos to end_pos.
+
+        Args:
+            entity (Entity): The entity to move.
+            start_pos (tuple[float, float]): The starting position of the entity.
+            end_pos (tuple[float, float]): The ending position of the entity.
+
+        Returns:
+            Callable[[float], None]: A function that updates the entity's position based on a progression value (0 to 1).
+        """
         def func(x):
             entity.set_center(start_pos[0]+(end_pos[0]-start_pos[0])*x,start_pos[1]+(end_pos[1]-start_pos[1])*x)
         return func
     
-    def animate_move_to(entity: "Object", end_pos: tuple[float, float]) -> Callable[[float], None]:
+    def animate_move_to(entity: "Entity", end_pos: tuple[float, float]) -> Callable[[float], None]:
+        """
+        Creates a function to animate the movement of an entity to a specified end position, capturing the start position at the start of the animation.
+
+        Args:
+            entity (Entity): The entity to move.
+            end_pos (tuple[float, float]): The target position of the entity.
+
+        Returns:
+            Callable[[float], None]: A function that updates the entity's position based on a progression value (0 to 1).
+        """
+
         # Start position will be captured once when the animation starts
         start_pos = [None]
 
@@ -140,10 +197,52 @@ class Utils:
         return update_position
 
     @staticmethod
-    def animate_alpha(entity:"Entity", start : int, end:int)->Callable[[float],None]:
+    def animate_alpha(entity:"Drawable", start : int, end:int)->Callable[[float],None]:
+        """
+        Creates a function to animate the alpha (transparency) of a drawable entity between a start and end value.
+
+        Args:
+            entity (Drawable): The entity to animate.
+            start (int): The starting alpha value (0 to 255).
+            end (int): The ending alpha value (0 to 255).
+
+        Returns:
+            Callable[[float], None]: A function that updates the entity's alpha based on a progression value (0 to 1).
+        """
         def func(x):
             entity.set_alpha(int(pygame.math.clamp(start+(end-start)*x,0,255)))
         return func
     
 
 
+    @staticmethod
+    def random_color(min_value: int = 0, max_value: int = 255) -> tuple[int, int, int]:
+        """
+        Generates a random color as an RGB tuple.
+
+        Args:
+            min_value (int): Minimum value for each RGB component (inclusive). Defaults to 0.
+            max_value (int): Maximum value for each RGB component (inclusive). Defaults to 255.
+
+        Returns:
+            tuple[int, int, int]: A tuple representing a random color in RGB format, with each component 
+            between min_value and max_value.
+        """
+        return random.randint(min_value, max_value), random.randint(min_value, max_value), random.randint(min_value, max_value)
+
+    @staticmethod
+    def random_point_on_screen(margin: int = 0) -> tuple[int, int]:
+        """
+        Generates a random point on the screen, considering a margin from the edges.
+
+        Args:
+            margin (int): Margin from the screen edges, where the point won't be generated. 
+                        If margin is less than 0 or greater than the screen resolution, returns (0, 0).
+
+        Returns:
+            tuple[int, int]: A tuple representing a random point (x, y) on the screen within the screen 
+            resolution minus the margin.
+        """
+        if margin < 0 or margin > bf.const.RESOLUTION[0] or margin > bf.const.RESOLUTION[1]:
+            return 0, 0
+        return random.randint(margin, bf.const.RESOLUTION[0] - margin), random.randint(margin, bf.const.RESOLUTION[1] - margin)

{batframework-1.0.8a13.dist-info → batframework-1.0.8a14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: batframework
-Version: 1.0.8a13
+Version: 1.0.8a14
 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.8a13.dist-info → batframework-1.0.8a14.dist-info}/RECORD

@@ -1,63 +1,63 @@
-batFramework/__init__.py,sha256=z-FvSCPuPSJw3y4VnvujiKS9NeqqjD07QmpT_rjwZFI,2542
+batFramework/__init__.py,sha256=DTeryYh2C-cZhmO6GQqfy-Lyjzdpa-KobxvQpIY1meM,2580
 batFramework/action.py,sha256=919IVYKviLyVYDtQL7oZvlVuE_aodjJCuwz6fGi5sCk,8420
 batFramework/actionContainer.py,sha256=qy6-YY3iX26KJ8NqFMSYo6JExohD8HFk0sC1qhb7qA8,2602
-batFramework/animatedSprite.py,sha256=aHv3a1m6ilhk1fXkWrkDRj9ud1snuR0wt1DUvGstLro,4240
+batFramework/animatedSprite.py,sha256=IWE8zUgpFaqQPUr7iOUo7TJ_E10aUaMNqlIqv8dW87E,4242
 batFramework/animation.py,sha256=_XcH6r3TVQZUcLbhzUnTNlXrjy-J-nYiRmFpxvTYEoc,1934
 batFramework/audioManager.py,sha256=8tKSf4huZe5tgH98qHlKoFNjXPGDQNJho6PKfSCe7JA,3869
 batFramework/camera.py,sha256=u1EPSitZ9mEEa32yQB7K6ywnWgWCSumbhrc4HRjimEY,9406
-batFramework/character.py,sha256=uXbhMh8p-O8FXF0-gQW5JFiFiuDlgMZ_icgd5xudjyQ,789
-batFramework/constants.py,sha256=5PyZQZ4fCcLA8k_Upby9KGVF-3pnV2ZZ6t26CxiocPM,1102
-batFramework/cutscene.py,sha256=Jh2g-zC3zaUSQoO2uVOsirWkuLAUFugu2T8B_ob9IPQ,4007
+batFramework/character.py,sha256=AK5sQLvAOY3X4-7vzeHeIO5WDFsubn_TADLYxmYc0Qo,789
+batFramework/constants.py,sha256=E6Z-q4n_PXGxkP_Lr0l-BmWwDHGcabtlj45yrqifCKg,1217
+batFramework/cutscene.py,sha256=FIry2kyDS1R8gHuEXKnsLz4XT30kf1Te1cjCLEK2Z24,4080
 batFramework/cutsceneBlocks.py,sha256=3jtmTpV48NKCu-Qgjg7KN5KnwXn0kycIQ7t7G3RH3VE,4862
+batFramework/drawable.py,sha256=oGj3qAh27FsCeQP2lKVBSTZ6NL4OEl3qgy3oapI02-8,2164
 batFramework/dynamicEntity.py,sha256=6WcI6OveFNmrtOUYzmVMlT35Hz4MXeeRKzd1M3meL1Q,876
 batFramework/easingController.py,sha256=4N8GIp1fsaWBUlDxXx3SMwOq1Mrhn10MZZIO51_CRnk,1677
-batFramework/entity.py,sha256=34gYC6uEMmLkqWtoTG9bgMWRmHRSxhQfxXZKzWS7H2o,2127
+batFramework/entity.py,sha256=vO42Hc2JAKtRAwOwMZNO27AtJR1Y1bJuhWEkr_K6TmY,3373
 batFramework/enums.py,sha256=re12gHw2g-5qtCNmGOfZbEC5cL5E8-FA79hfKGrI6-I,2078
 batFramework/fontManager.py,sha256=iCVavr4hpn0T4xsaUAzdNd01j5ebpcj30fvFHzm1g-M,2246
-batFramework/manager.py,sha256=PbpwCr9CoRszEepKx2R4jHt1_ZCzZOxMzdnO8H8767g,4162
-batFramework/object.py,sha256=_3sfRxrjaiDuVyz5Yk-fYJqYx-Ehq_3-dA4eDTb9kok,3329
-batFramework/particle.py,sha256=SD_DRqfhzlEeWlORDVPh1R__2_RplNcBujmqovN9Mww,3079
+batFramework/manager.py,sha256=FXeBe7w98H1YHspTmXjyZe0-_QPXh6ZpBH84eYghDgo,4243
+batFramework/particle.py,sha256=Aps9eJNdFag-TlduMSezKp4ocFQVvI6iZ98chhdhbgE,3081
 batFramework/renderGroup.py,sha256=_VDvmP4iB-XarFJo_Uh5YKwWq1cazHmOBmTXZkqKk40,2020
 batFramework/resourceManager.py,sha256=0cOIAFXT7UzzvgHn9QkWcXsTp8H2bIS70NvvgpBL2_4,3554
-batFramework/scene.py,sha256=2fXxwle68jzHwR2irKeWJYL95uAVmmU2edexo9p7fu4,12197
-batFramework/sceneManager.py,sha256=Jb51KksIDrZrXUafs0bgX73tY-8rglWW89Co48YGdCM,8037
+batFramework/scene.py,sha256=0E7omgNUEl5Uhbx8iO3exyCy4p1MC7bSvqfwncW4KMw,11281
+batFramework/sceneManager.py,sha256=ZH-vQbppwhg63EEdk7ahRpZ-K1TnB7BKVxD7y7IRSjM,7356
 batFramework/scrollingSprite.py,sha256=PPEieAaFcOLE_Lm7cnm3xc7XyLKopCPcDbXEfyThO48,4133
-batFramework/sprite.py,sha256=t_kSyUXGOSXQbSBwrKgBUTp5mITeFQbAKNzugjL5SgY,1625
+batFramework/sprite.py,sha256=Cz8qzl8jR8y33DUSCObJQOk5e8PcZeavtFhBdR2TogU,1627
 batFramework/stateMachine.py,sha256=wC-5xbKvf-vGm_N16X9KhgMya5915GyVXL79uk5Bapw,1359
 batFramework/tileset.py,sha256=3AJBWHx90PC43BdLYCBFm811XBrMvWoB-nsUgyo6s-I,1728
-batFramework/time.py,sha256=iLDuHPQVNcPrNfqN6UP67d34HuC8Y42s6cdiTE53o7o,4989
+batFramework/timeManager.py,sha256=XcqPs_74pjXafi6oNJe8W85SVfXTfPmOZOQyLOuyt8I,4987
 batFramework/transition.py,sha256=-1cyk-7Fbm0U2Z4Y2jjpLHwJ2khM1VxIMcfk2bBEo-M,6655
 batFramework/triggerZone.py,sha256=wIxkvO0cVVupQsJIPOD_-ofqwLnu1TLNK-n6oNXB1E8,579
-batFramework/utils.py,sha256=kj0qaOwpwvvPMD1DyOQTZLYeV-1lJ0dobeU2E49Rwg8,5215
+batFramework/utils.py,sha256=G9TBEFW6Okm4H7ohikG1GIf6d1pdql8ZBdhkpK5yyys,9969
 batFramework/gui/__init__.py,sha256=17ij7mrCBCoehqCq1PV6MSXPOfMoLPmrV_G8d6ax4Tk,687
 batFramework/gui/button.py,sha256=Ozs6VKHf9FCQXQODDiLQywGN3hwfXtQ6s2I-rzdjnQg,429
 batFramework/gui/clickableWidget.py,sha256=2vS9GFSI3uufYQbaosXxTMs81vyVfQGz71AeZmf8vcY,7049
-batFramework/gui/container.py,sha256=wXjuhwCJc71KKSgY2cYgoRscAKB_hIw5N4njJk3Z9lk,5925
-batFramework/gui/debugger.py,sha256=XogxF3J31GO-DZZn6YBrgwpYA5WjadzEfHkQHeMLU7o,3925
+batFramework/gui/container.py,sha256=4FOVYmxpn9HM_-J20YWR7u2sj9kwpJldb4Cfc-2hmi4,5927
+batFramework/gui/debugger.py,sha256=0VTQvhSD5zLjbVhs97ldeBLXqnFLlua-zTCpWB9OBGQ,3928
 batFramework/gui/dialogueBox.py,sha256=3Z76l9obrpQImI8hjoBS_8G9sY3UILj2d3nJsaxtaI4,3221
 batFramework/gui/draggableWidget.py,sha256=SKG7oMInZ_GTnrbv2T0aqlppuiuLX1tkVSCQJtRMlk8,1392
 batFramework/gui/image.py,sha256=7IRvalA6QQz7SYI9h4y4-ryWa9EOxZM3sc10-OZyCPc,1770
 batFramework/gui/indicator.py,sha256=leCvxsGxt00-oTn0N5MTmLstLH9uLG3RjQ02KlXtZCQ,1549
 batFramework/gui/interactiveWidget.py,sha256=FAZnSlMIohduZIDTZh5U-_mh1AbgTF4sz-0oig4LWIQ,5760
-batFramework/gui/label.py,sha256=FmSY-ABOJKA47AFkbC8z99cOtJ1Ev6X12Ysdlq13iFI,11799
+batFramework/gui/label.py,sha256=WWc_AdxC0ZJzyT478SrUAQUhERsihr2KsTRfVLdPOiQ,11178
 batFramework/gui/layout.py,sha256=3nprthjCJqUdD1qHN3lReYRb-4L0-t6v51JEO4NRcgo,8563
 batFramework/gui/meter.py,sha256=RFzAhSzR3O-Pw0wjdfApWGWFQSJoYa4WohkiREDAAJc,2395
 batFramework/gui/radioButton.py,sha256=rROl9mtUa-m220R5qZ85NBPZS7nPVx-azhqijJ-XhCo,2411
-batFramework/gui/root.py,sha256=K75814ct6AF4LF8cyzmtUmnTmSflJRnHVMGbpUXwmkE,5084
+batFramework/gui/root.py,sha256=OsRmbh-UdIDrAqolwa5IV76iSksu_ByVo0WQp0YCSUQ,4812
 batFramework/gui/shape.py,sha256=Ros_-Mm2Q2CFauZFqFPh1QyyuZnNmg7C2PYbs7Cq41k,9347
 batFramework/gui/slider.py,sha256=5d3rfTYjDCDiM5prKu6DTemlGgji2FQ_vGuLzxoa5gU,8335
 batFramework/gui/style.py,sha256=OeLbft0RkIslQ2IcZpBeF6TaQDONIoBcAHj_Bkh9gFw,131
 batFramework/gui/styleManager.py,sha256=rALKJ-AmRbDAiyu8hVAYRAlkQxw677DiPoNKJZ4xtJ4,1245
 batFramework/gui/textInput.py,sha256=aTegghN6O3djL0eBEEij9DsEuZ1MyE61P51IzaLUUEg,9324
 batFramework/gui/toggle.py,sha256=XLFzCRaY7uOkKFVtR3y01wsNjLjZqrS1748IcvBRN2Q,3969
-batFramework/gui/widget.py,sha256=HGusTCgh3oAjtvrShzn2YxhFTGgNLsqGGhNilvRx-oo,13883
+batFramework/gui/widget.py,sha256=2tehCiSLum0pwz3KNlrwc5SYvkZ7Hs0FiqtbmXuLoJs,13885
 batFramework/gui/constraints/__init__.py,sha256=qqXE8nnSrEvCSeHdqY8UYPZLetqdubFPI7IdZuh35QE,26
 batFramework/gui/constraints/constraints.py,sha256=nyPew0HIJ24rl4JcdBjUYu2aFynTryN9wqv1wKCo4ew,26873
 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.8a13.dist-info/LICENCE,sha256=A65iXbMDbOxQLDNOODJLqA7o5RxszYlEqIgNSzBQRf4,1073
-batframework-1.0.8a13.dist-info/METADATA,sha256=OzyhEot1q6_IE63BpCHk_FVARFPT-Wq8J4DTNke2DSo,1695
-batframework-1.0.8a13.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-batframework-1.0.8a13.dist-info/top_level.txt,sha256=vxAKBIk1oparFTxeXGBrgfIO7iq_YR5Fv1JvPVAIwmA,13
-batframework-1.0.8a13.dist-info/RECORD,,
+batframework-1.0.8a14.dist-info/LICENCE,sha256=A65iXbMDbOxQLDNOODJLqA7o5RxszYlEqIgNSzBQRf4,1073
+batframework-1.0.8a14.dist-info/METADATA,sha256=avsotELk-g0Ts9vQWsdLuFQzvXohhiarcDY9UodilRg,1695
+batframework-1.0.8a14.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+batframework-1.0.8a14.dist-info/top_level.txt,sha256=vxAKBIk1oparFTxeXGBrgfIO7iq_YR5Fv1JvPVAIwmA,13
+batframework-1.0.8a14.dist-info/RECORD,,

batFramework/object.py

@@ -1,123 +0,0 @@
-from typing import Any, Self
-import pygame
-import batFramework as bf
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from .camera import Camera
-
-
-class Object:
-    __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.render_order: int = 0
-        self.uid: int = Object.__count
-        Object.__used_uid.add(self.uid)
-
-        if Object.__available_uid:
-            self.name = Object.__available_uid.pop()
-        else:
-            self.name = Object.__count
-            Object.__count += 1
-
-    def __del__(self):
-        Object.__available_uid.add(self.uid)
-
-    def set_position(self, x, y) -> Self:
-        self.rect.topleft = x, y
-        return self
-
-    def set_center(self, x, y) -> Self:
-        self.rect.center = x, y
-        return self
-
-    def get_debug_outlines(self):
-        yield (self.rect, self.debug_color)
-
-    def set_debug_color(self, color) -> Self:
-        self.debug_color = color
-        return self
-
-    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 do_when_added(self):
-        pass
-
-    def do_when_removed(self):
-        pass
-
-    def set_uid(self, uid: int) -> Self:
-        if uid in Object.__used_uid:
-            print(f"set_uid error : UID '{uid}' is already in use")
-            return self
-        self.uid = uid
-        Object.__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:
-        """
-        Returns bool : True if the method is blocking (no propagation to next object of the scene)
-        """
-        if event.consumed:
-            return
-        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 object (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
-        """