batframework 0.1.13__py3-none-any.whl → 1.0.1__py3-none-any.whl

batFramework/scene.py

@@ -1,14 +1,23 @@
 from __future__ import annotations
 import re
-from typing import TYPE_CHECKING,Any
+from typing import TYPE_CHECKING, Any
+
 if TYPE_CHECKING:
     from .manager import Manager
+    from .sceneManager import SceneManager
 import pygame
 import batFramework as bf
 
 
 class Scene:
-    def __init__(self, name, enable_alpha=True) -> None:
+    def __init__(self, name: str, enable_alpha: bool = True) -> None:
+        """
+        Initialize the Scene object.
+
+        Args:
+            name: Name of the scene.
+            enable_alpha (bool, optional): Enable alpha channel for the scene surfaces. Defaults to True.
+        """
         self._name = name
         self._active = False
         self._visible = False
@@ -16,71 +25,107 @@ class Scene:
         self._hud_entities: list[bf.Entity] = []
         self.manager: Manager | None = None
         self.actions: bf.ActionContainer = bf.ActionContainer()
-        self.camera: bf.Camera = bf.Camera()
         self.scene_index = 0
-        self.hud_camera: bf.Camera = bf.Camera()
-        if enable_alpha:
-            self.camera.surface = self.camera.surface.convert_alpha()
-            self.hud_camera.surface = self.camera.surface.convert_alpha()
-
-            self.camera.set_clear_color((0, 0, 0))
-            self.hud_camera.set_clear_color((0, 0, 0, 0))
+        self.camera: bf.Camera = bf.Camera(convert_alpha=enable_alpha)
+        self.hud_camera: bf.Camera = bf.Camera(convert_alpha=enable_alpha)
 
-        self.root  : bf.Root = bf.Root()
+        self.root: bf.Root = bf.Root()
         self.root.set_center(*self.hud_camera.get_center())
         self.add_hud_entity(self.root)
         self.blit_calls = 0
 
-    def set_scene_index(self,index):
+
+    def get_world_entity_count(self)->int:
+        return len(self._world_entities)
+
+
+    def get_hud_entity_count(self)->int:
+        return len(self._world_entities) + self.root.count_children_recursive() -1
+
+
+    def set_scene_index(self, index: int):
+        """Set the scene index."""
         self.scene_index = index
 
-    def get_scene_index(self):
+    def get_scene_index(self) -> int:
+        """Get the scene index."""
         return self.scene_index
 
-    def set_sharedVar(self, name, value)->bool:
-        if not self.manager : return False 
+    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)->Any:
-        if not self.manager : return False 
+    def get_sharedVar(self, name: str) -> 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 False
         return self.manager.get_sharedVar(name)
 
     def do_when_added(self):
         pass
 
-    def set_clear_color(self, color: pygame.Color|tuple):
+    def set_clear_color(self, color: pygame.Color | tuple):
+        """Set the clear color for the camera."""
         self.camera.set_clear_color(color)
-        # self.hud_camera.set_clear_color(color)
 
     def set_manager(self, manager_link: Manager):
+        """Set the manager link for the scene."""
         self.manager = manager_link
+        self.manager.update_scene_states()
 
     def set_visible(self, value: bool):
+        """Set the visibility of the scene."""
         self._visible = value
-        if self.manager : self.manager.update_scene_states()
+        if self.manager:
+            self.manager.update_scene_states()
 
     def set_active(self, value):
+        """Set the activity of the scene."""
         self._active = value
-        if self.manager : self.manager.update_scene_states()
+        if self.manager:
+            self.manager.update_scene_states()
 
     def is_active(self) -> bool:
+        """Check if the scene is active."""
         return self._active
 
     def is_visible(self) -> bool:
+        """Check if the scene is visible."""
         return self._visible
 
     def get_name(self) -> str:
+        """Get the name of the scene."""
         return self._name
 
     def add_world_entity(self, *entity: bf.Entity):
+        """Add world entities to the scene."""
         for e in entity:
-            if e not in self._world_entities:
-
-                self._world_entities.append(e)
-                e.parent_scene = self
-                e.do_when_added()
+            self._world_entities.append(e)
+            e.parent_scene = self
+            e.do_when_added()
+        self.sort_entities()
 
     def remove_world_entity(self, *entity: bf.Entity):
+        """Remove world entities from the scene."""
         for e in entity:
             if e not in self._world_entities:
                 return False
@@ -90,13 +135,16 @@ class Scene:
             return True
 
     def add_hud_entity(self, *entity: bf.Entity):
+        """Add HUD entities to the scene."""
         for e in entity:
-            if e not in self._hud_entities:
-                self._hud_entities.append(e)
-                e.parent_scene = self
-                e.do_when_added()
+            self._hud_entities.append(e)
+            e.parent_scene = self
+            e.do_when_added()
+        self.sort_entities()
+        return True
 
     def remove_hud_entity(self, *entity: bf.Entity):
+        """Remove HUD entities from the scene."""
         for e in entity:
             if e in self._hud_entities:
                 e.do_when_removed()
@@ -104,30 +152,44 @@ class Scene:
                 self._hud_entities.remove(e)
 
     def add_action(self, *action):
+        """Add actions to the scene."""
         self.actions.add_action(*action)
 
     def get_by_tags(self, *tags):
-        res =  [
+        """Get entities by their tags."""
+        res = [
             entity
             for entity in self._world_entities + self._hud_entities
-            if any(entity.has_tag(t) for t in tags)
+            if any(entity.has_tags(t) for t in tags)
         ]
-        res.extend(
-            list(self.root.get_by_tags(*tags))
-        )
+        res.extend(list(self.root.get_by_tags(*tags)))
         return res
 
     def get_by_uid(self, uid) -> bf.Entity | None:
-        return next(
-            (
-                entity
-                for entity in self._world_entities + self._hud_entities
-                if entity.uid == uid
-            ),
-            None,
-        )
-        # TODO
-        # ADD FOR WIDGETS TOO TOO
+        """Get an entity by its unique identifier."""
+        res = self._find_entity_by_uid(uid, self._world_entities + self._hud_entities)
+        if res is None:
+            res = self._recursive_search_by_uid(uid, self.root)
+        return res
+
+    def _find_entity_by_uid(self, uid, entities) -> bf.Entity | None:
+        """Search for entity by uid in a list of entities."""
+        for entity in entities:
+            if entity.uid == uid:
+                return entity
+        return None
+
+    def _recursive_search_by_uid(self, uid, widget) -> bf.Entity | None:
+        """Recursively search for entity by uid in the widget's children."""
+        if widget.uid == uid:
+            return widget
+
+        for child in widget.children:
+            res = self._recursive_search_by_uid(uid, child)
+            if res is not None:
+                return res
+        
+        return None
 
     # called before process event
     def do_early_process_event(self, event: pygame.Event) -> bool:
@@ -140,20 +202,19 @@ class Scene:
         Propagates event to child events. Calls early process event first, if returns False then stops. Processes scene's action_container, then custom do_handle_event function.
         Finally resets the action_container, and propagates to all child entities. if any of them returns True, the propagation is stopped.
         """
-        if self.get_sharedVar("in_transition"):
-            return
+
         if self.do_early_process_event(event):
             return
         self.actions.process_event(event)
         self.do_handle_actions()
         self.do_handle_event(event)
-        for entity in self._world_entities + self._hud_entities:
+        for entity in self._hud_entities + self._world_entities:
             if entity.process_event(event):
                 break
-        
-        self.actions.reset()
 
-    def do_handle_actions(self)->None:
+
+    def do_handle_actions(self) -> None:
+        """Handle actions within the scene."""
         pass
 
     def do_handle_event(self, event: pygame.Event):
@@ -161,13 +222,16 @@ class Scene:
         pass
 
     def update(self, dt):
+        """Update the scene. Do NOT override"""
         for entity in self._world_entities + self._hud_entities:
             entity.update(dt)
         self.do_update(dt)
         self.camera.update(dt)
         self.hud_camera.update(dt)
+        self.actions.reset()
 
     def do_update(self, dt):
+        """Specific update within the scene."""
         pass
 
     def debug_entity(self, entity: bf.Entity, camera: bf.Camera):
@@ -176,56 +240,52 @@ class Scene:
             return
         # print(entity,entity.visible)
         for data in entity.get_bounding_box():
-            if isinstance(data,pygame.FRect):
+            if isinstance(data, pygame.FRect):
                 rect = data
-                color = entity._debug_color
+                color = entity.debug_color
             else:
                 rect = data[0]
                 color = data[1]
-            if not isinstance(color,pygame.Color): color = pygame.Color(color)
+            # if not isinstance(color, pygame.Color):
+            #     color = pygame.Color(color)
 
-            pygame.draw.rect(camera.surface, color , camera.transpose(rect), 1)
+            pygame.draw.rect(camera.surface, color, camera.transpose(rect), 1)
 
-    def draw(self, surface: pygame.Surface):
-        self._world_entities.sort(key=lambda e: (e.z_depth, e.render_order))
-        self._hud_entities.sort(key=lambda e: (e.z_depth, e.render_order))
+    def sort_entities(self) -> None:
+        """Sort entities within the scene based on their rendering order."""
+        self._world_entities.sort(key=lambda e: e.render_order)
+        self._hud_entities.sort(key=lambda e: e.render_order)
 
+    def draw(self, surface: pygame.Surface):
         total_blit_calls = 0
+        if not self.manager : return
         self.camera.clear()
         self.hud_camera.clear()
 
-        debug_2_or_3 = self.manager and self.manager._debugging in [2, 3]
-        debug_3 = debug_2_or_3 and self.manager._debugging == 3
+        show_outlines = self.manager._debugging in [2, 3]
+        show_only_visible_outlines = self.manager._debugging != 3
 
-        total_blit_calls += sum(
-            entity.draw(self.camera) for entity in self._world_entities
-            if not (debug_2_or_3 and ((debug_3 and not entity.visible) or not debug_3))
-        )
 
-        if debug_2_or_3:
-            for entity in self._world_entities:
-                if debug_3 and not entity.visible:
-                    continue
-                self.debug_entity(entity, self.camera)
+        #   draw all world entities
+        total_blit_calls += sum(entity.draw(self.camera) for entity in self._world_entities)
 
-        total_blit_calls += sum(
-            entity.draw(self.hud_camera) for entity in self._hud_entities
-            if not (debug_2_or_3 and ((debug_3 and not entity.visible) or not debug_3))
-        )
+        #   
+        if show_outlines:
+            [self.debug_entity(entity, self.camera) for entity\
+            in self._world_entities if not  show_only_visible_outlines\
+            or (show_only_visible_outlines and entity.visible)]
 
-        if debug_2_or_3:
-            for entity in self._hud_entities:
-                if debug_3 and not entity.visible:
-                    continue
-                self.debug_entity(entity, self.hud_camera)
+        total_blit_calls += sum(entity.draw(self.hud_camera) for entity in self._hud_entities)
 
+        if show_outlines:
+            [self.debug_entity(entity, self.hud_camera) for entity\
+            in self._hud_entities if  not show_only_visible_outlines\
+            or (show_only_visible_outlines and entity.visible)]
 
         self.do_early_draw(surface)
         self.camera.draw(surface)
-        self.do_post_world_draw(surface)
         self.hud_camera.draw(surface)
         self.do_final_draw(surface)
-
         self.blit_calls = total_blit_calls
 
     def do_early_draw(self, surface: pygame.Surface):
@@ -242,10 +302,8 @@ class Scene:
         self.set_visible(True)
         self.root.build()
 
-
     def on_exit(self):
-        self.root.focus_on(None)
-        self.root.hover = None
+        self.root.reset()
         self.set_active(False)
         self.set_visible(False)
         self.actions.hard_reset()

batFramework/sceneManager.py

@@ -2,18 +2,17 @@ import batFramework as bf
 import pygame
 
 
-
 class SceneManager:
     def __init__(self, *initial_scenes: bf.Scene) -> None:
         self._debugging = 0
         self.sharedVarDict = {}
 
         self.transitions: list[bf.BaseTransition] = []
-        self.set_sharedVar("is_debugging_func", lambda: self._debugging)
+        self.set_sharedVar("debugging_mode",self._debugging)
         self.set_sharedVar("in_cutscene", False)
 
         self._scenes: list[bf.Scene] = list(initial_scenes)
-        for index,s in enumerate(self._scenes):
+        for index, s in enumerate(self._scenes):
             s.set_manager(self)
             s.set_scene_index(index)
             s.do_when_added()
@@ -22,7 +21,7 @@ class SceneManager:
 
     def print_status(self):
         print("-" * 40)
-        print([(s._name, s._active, s._visible,s.scene_index) for s in self._scenes])
+        print([(s._name, s._active, s._visible, s.scene_index) for s in self._scenes])
         print(f"[Debugging] = {self._debugging}")
         print("---SHARED VARIABLES---")
         _ = [
@@ -39,11 +38,11 @@ class SceneManager:
         if name not in self.sharedVarDict:
             return None
         return self.sharedVarDict[name]
-    
-    def get_current_scene_name(self)-> str:
-        return self._scenes[0].name
-    
-    def get_current_scene(self)->bf.Scene:
+
+    def get_current_scene_name(self) -> str:
+        return self._scenes[0].get_name()
+
+    def get_current_scene(self) -> bf.Scene:
         return self._scenes[0]
 
     def update_scene_states(self):
@@ -72,20 +71,25 @@ class SceneManager:
 
     def transition_to_scene(self, dest_scene_name, transition, **kwargs):
         self.set_scene(dest_scene_name)
-        
-    def set_scene(self, name,index=0):
-        if len(self._scenes)==0 or not self.has_scene(name) or index>=len(self._scenes):return
 
+    def set_scene(self, name, index=0):
         target_scene = self.get_scene(name)
+        if (
+            len(self._scenes) == 0
+            or not target_scene
+            or index >= len(self._scenes)
+            or index < 0
+        ):
+            return
+
         old_scene = self._scenes[index]
-        #switch
+        # switch
         old_scene.on_exit()
         self.remove_scene(name)
-        self._scenes.insert(index,target_scene)
-        _ = [s.set_scene_index(i) for i,s in enumerate(self._scenes)]
+        self._scenes.insert(index, target_scene)
+        _ = [s.set_scene_index(i) for i, s in enumerate(self._scenes)]
         target_scene.on_enter()
 
-
     def process_event(self, event: pygame.Event):
         keys = pygame.key.get_pressed()
         if (
@@ -94,6 +98,7 @@ class SceneManager:
             and event.key == pygame.K_d
         ):
             self._debugging = (self._debugging + 1) % 4
+            self.set_sharedVar("debugging_mode",self._debugging)
             return
         if (
             keys[pygame.K_LCTRL]

batFramework/sprite.py

@@ -0,0 +1,31 @@
+import batFramework as bf
+import pygame
+from typing import Self
+
+class Sprite(bf.DynamicEntity):
+    def __init__(
+        self,
+        data: pygame.Surface | str,
+        size: None | tuple[int, int] = None,
+        convert_alpha: bool = True,
+    ):
+        self.original_surface = None
+        super().__init__(convert_alpha=convert_alpha)
+        if data:
+            self.set_image(data, size)
+    
+    def set_image(
+        self, data: pygame.Surface | str, size: None | tuple[int, int] = None
+    ):
+        if isinstance(data, str):
+            tmp = bf.ResourceManager().get_image(data,self.convert_alpha)
+            self.original_surface = tmp
+        elif isinstance(data, pygame.Surface):
+            self.original_surface = data
+        if self.convert_alpha:
+            self.original_surface = self.original_surface.convert_alpha()
+        if not size:
+            size = self.original_surface.get_size()
+        self.surface = pygame.transform.scale(self.original_surface, size)
+        self.rect = self.surface.get_frect(center=self.rect.center)
+

batFramework/stateMachine.py

@@ -44,6 +44,7 @@ class StateMachine:
                 self.current_state.on_exit()
             self.current_state = self.states[state_name]
             self.current_state.on_enter()
+
     def get_current_state(self) -> State:
         return self.current_state
 

batFramework/tileset.py

@@ -1,15 +1,15 @@
-import pygame 
+import pygame
 from .utils import Utils
 
+
 class Tileset:
     _tilesets = {}
     _flip_cache = {}  # {"tileset":tileset,"index","flipX","flipY"}
 
-    def __init__(self, source: pygame.Surface|str, tilesize) -> None:
-
-        if isinstance(source,str):
+    def __init__(self, source: pygame.Surface | str, tilesize) -> None:
+        if isinstance(source, str):
             source = pygame.image.load(Utils.get_path(source)).convert_alpha()
-            
+
         self.tile_dict = {}
         self.surface = source
         self.tile_size = tilesize
@@ -48,13 +48,11 @@ class Tileset:
         return self.tile_dict[(x, y)]
 
     @staticmethod
-    def load_tileset(path: str, name: str, tilesize)->"Tileset":
+    def load_tileset(path: str, name: str, tilesize) -> "Tileset":
         if name in Tileset._tilesets:
             return Tileset._tilesets[name]
         else:
-            img = pygame.image.load(
-                Utils.get_path(path)
-            ).convert_alpha()
+            img = pygame.image.load(Utils.get_path(path)).convert_alpha()
             tileset = Tileset(img, tilesize)
             Tileset._tilesets[name] = tileset
             return tileset

batFramework/time.py

@@ -1,74 +1,85 @@
 import pygame
 import batFramework as bf
+from typing import Self
 
 class Timer:
-    _highest_count = 0
-    def __init__(self, name=None, duration=1000, loop=False, end_callback=None,reusable:bool=False):
-        # Initialize timer properties
-        self.start_time = None
-        self.stopped = True
-        self.name = name if name is not None else self._highest_count
-        Timer._highest_count += 1
-        self.duration = duration
-        self.loop = loop
-        self.elapsed_progress = 0.0
+    _count :int = 0
+    def __init__(self,duration:int,end_callback,loop:bool=False)->None:
+        self.name = Timer._count
+        Timer._count+=1
         self.end_callback = end_callback
-        self.reusable:bool = reusable
-    def start(self):
-        # Start the timer and set the start time
-        if self.start_time is None:
-            Time().add_timer(self)
-            
-        self.start_time = pygame.time.get_ticks()
-        self.stopped = False
-        self.elapsed_progress = 0.0
-        
-    def update(self):
-        if self.stopped : return False
-        current_time = pygame.time.get_ticks()
-        if self.elapsed_progress < 1:
-            # Calculate elapsed progress
-            self.elapsed_progress = (current_time - self.start_time) / self.duration            
-            if self.elapsed_progress >= 1:
-                # Timer has completed
-                self.end()
-                return True
-        elif self.loop:
-            # If looping, restart the timer
-             self.start()
-        return False
+        self.duration : int = duration
+        self.paused : bool = False
+        self.elapsed_time : int = -1
+        self.over : bool = False  
+        self.do_delete:bool = False
+        self.is_looping :bool = loop 
 
-    def stop(self):
-        # Stop the timer
-        self.stopped = True
+    def stop(self)->Self:
+        self.elapsed_time =-1
+        self.over = False
+        self.paused = False
+        return self
+    
+    def start(self)->Self:
+        if self.elapsed_time >= 0 : return self
+        self.elapsed_time = 0
+        self.paused = False
+        self.over = False
+        bf.TimeManager().add_timer(self)
+        return self
+        
+    def pause(self)->Self:
+        self.paused = True
+        return self
 
+    def resume(self)->Self:
+        self.paused = False
+        return self
+    def delete(self)->Self:
+        self.do_delete = True
+        return self
+    def get_progression(self)->float:
+        if self.elapsed_time < 0 : return 0
+        if self.elapsed_time >= self.duration: return 1
+        return  self.elapsed_time / self.duration
+        
+    def update(self,dt)->None:
+        if self.elapsed_time < 0 or self.paused: return
+        self.elapsed_time += dt
+        # print("update :",self.elapsed_time,self.duration)
+        if self.get_progression() == 1:
+            self.end()
+            
     def end(self):
-        self.elapsed_progress = 1
-        self.stopped = False
-        if self.end_callback:
-            self.end_callback()
+        print("END")
+        self.end_callback()
+        if self.is_looping:
+            self.elapsed_time = -1
+            self.start()
+            return
+            
+        self.over = True
 
-    def ended(self):
-        if self.start_time is None:
-            return False
-        return (not self.loop) and (self.elapsed_progress >= 1) and (not self.stopped) and not self.reusable
+    def has_ended(self)->bool:
+        return self.over or self.do_delete
 
 
-class Time(metaclass=bf.Singleton):
+class TimeManager(metaclass=bf.Singleton):
     def __init__(self):
-        # Initialize the Time class with a dictionary of timers
+        # Initialize the TimeManager class with a dictionary of timers
         self.timers = {}
 
     def add_timer(self, timer):
         # Add a timer to the dictionary
         self.timers[timer.name] = timer
 
-    def update(self):
+    def update(self,dt):
         # Update all timers and remove completed ones
         for timer in list(self.timers.values()):
-            timer.update()
+            timer.update(dt)
 
-        to_remove = [name for name, timer in self.timers.items() if timer.ended()]
+        to_remove = [name for name, timer in self.timers.items() if timer.has_ended()]
 
         for name in to_remove:
             # print(self.timers.pop(name).name,"removed !")