batframework 1.0.7__py3-none-any.whl → 1.0.8a2__py3-none-any.whl

batFramework/scene.py

@@ -1,132 +1,86 @@
 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: 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.scene_index = 0
+    def __init__(self, name, enable_alpha=True) -> None:
         self._name = name
-        self.manager: Manager | None = None
         self._active = False
         self._visible = False
         self._world_entities: list[bf.Entity] = []
         self._hud_entities: list[bf.Entity] = []
+        self.manager: Manager | None = None
         self.actions: bf.ActionContainer = bf.ActionContainer()
-        self.early_actions: bf.ActionContainer = bf.ActionContainer()
-        self.camera: bf.Camera = bf.Camera(convert_alpha=enable_alpha)
-        self.hud_camera: bf.Camera = bf.Camera(convert_alpha=True)
+        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.root: bf.Root = bf.Root(self.hud_camera)
+        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 get_world_entity_count(self)->int:
-        return len(self._world_entities)
-
-
-    def get_hud_entity_count(self)->int:
-        return len(self._hud_entities) + self.root.count_children_recursive() -1
-
-
-    def set_scene_index(self, index: int):
-        """Set the scene index."""
+    def set_scene_index(self,index):
         self.scene_index = index
 
-    def get_scene_index(self) -> int:
-        """Get the scene index."""
+    def get_scene_index(self):
         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
+    def set_sharedVar(self, name, value)->bool:
+        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 get_sharedVar(self, name)->Any:
+        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):
-        """Set the clear color for the camera."""
+    def set_clear_color(self, color: pygame.Color|tuple):
         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:
-            self._world_entities.append(e)
-            e.parent_scene = self
-            e.do_when_added()
-        self.sort_entities()
+            if e not in self._world_entities:
+
+                self._world_entities.append(e)
+                e.parent_scene = self
+                e.do_when_added()
 
     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
@@ -136,65 +90,38 @@ class Scene:
             return True
 
     def add_hud_entity(self, *entity: bf.Entity):
-        """Add HUD entities to the scene."""
         for e in entity:
-            self._hud_entities.append(e)
-            e.parent_scene = self
-            e.do_when_added()
-        self.sort_entities()
-        return True
+            if e not in self._hud_entities:
+                self._hud_entities.append(e)
+                e.parent_scene = self
+                e.do_when_added()
 
     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()
                 e.parent_scene = None
                 self._hud_entities.remove(e)
 
-    def add_actions(self, *action):
-        """Add actions to the scene."""
+    def add_action(self, *action):
         self.actions.add_action(*action)
 
-    def add_early_actions(self, *action):
-        """Add actions to the scene."""
-        self.early_actions.add_action(*action)
-
     def get_by_tags(self, *tags):
-        """Get entities by their tags."""
-        res = [
+        return [
             entity
             for entity in self._world_entities + self._hud_entities
-            if any(entity.has_tags(t) for t in tags)
+            if any(entity.has_tag(t) for t in tags)
         ]
-        res.extend(list(self.root.get_by_tags(*tags)))
-        return res
 
     def get_by_uid(self, uid) -> bf.Entity | None:
-        """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
+        return next(
+            (
+                entity
+                for entity in self._world_entities + self._hud_entities
+                if entity.uid == uid
+            ),
+            None,
+        )
 
     # called before process event
     def do_early_process_event(self, event: pygame.Event) -> bool:
@@ -207,91 +134,77 @@ 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.early_actions.process_event(event)
-        self.do_handle_actions()
+        self.actions.process_event(event)
         self.do_handle_event(event)
-        for entity in self._hud_entities + self._world_entities:
+        for entity in self._world_entities + self._hud_entities:
             if entity.process_event(event):
-                return
-        self.actions.process_event(event)
-
-
-    def do_handle_actions(self) -> None:
-        """Handle actions within the scene."""
-        pass
+                break
+        self.actions.reset()
 
     def do_handle_event(self, event: pygame.Event):
         """called inside process_event but before resetting the scene's action container and propagating event to child entities of the 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()
-        self.early_actions.reset()
 
     def do_update(self, dt):
-        """Specific update within the scene."""
         pass
 
     def debug_entity(self, entity: bf.Entity, camera: bf.Camera):
+        # return
         if not entity.visible:
             return
-        # bounding_box = entity.get_bounding_box()
-        # if bounding_box is None : return
         for data in entity.get_bounding_box():
-            if data is None : return
-            if isinstance(data, pygame.FRect) or  isinstance(data, pygame.Rect):
+            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)
 
-            pygame.draw.rect(camera.surface, color, camera.transpose(rect), 1)
-
-    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)
+            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))
+
         total_blit_calls = 0
-        if not self.manager : return
         self.camera.clear()
         self.hud_camera.clear()
 
-        show_outlines = self.manager._debugging in [2, 3]
-        show_only_visible_outlines = self.manager._debugging != 3
-
 
-        #   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.camera) for entity in self._world_entities
+        )
 
-        #   
-        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 self.manager and  self.manager._debugging == 2:
+            for entity in self._world_entities:
+                self.debug_entity(entity, self.camera)
 
-        total_blit_calls += sum(entity.draw(self.hud_camera) for entity in self._hud_entities)
+        total_blit_calls += sum(
+            entity.draw(self.hud_camera) for entity in self._hud_entities
+        )
+        if  self.manager and  self.manager._debugging == 2:
+            for entity in self._hud_entities:
+                self.debug_entity(entity, self.hud_camera)
 
-        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):
@@ -306,22 +219,8 @@ class Scene:
     def on_enter(self):
         self.set_active(True)
         self.set_visible(True)
-        self.root.clear_hovered()
-        self.root.clear_focused()
-        self.root.build()
-        self.do_on_enter()
 
     def on_exit(self):
-        self.root.clear_hovered()
-        self.root.clear_focused()
         self.set_active(False)
         self.set_visible(False)
         self.actions.hard_reset()
-        self.early_actions.hard_reset()
-        self.do_on_exit()
-
-    def do_on_enter(self)->None:
-        pass
-
-    def do_on_exit(self)->None:
-        pass

batFramework/sceneManager.py

@@ -2,18 +2,19 @@ import batFramework as bf
 import pygame
 
 
+
 class SceneManager:
     def __init__(self, *initial_scenes: bf.Scene) -> None:
-        self._debugging :int = 0
-        self._sharedVarDict : dict = {}
+        self._debugging = 0
+        self.sharedVarDict = {}
 
-        self._scene_transitions: list = []
-        self.set_sharedVar("debugging_mode",self._debugging)
+        self.transitions: list[bf.BaseTransition] = []
+        self.set_sharedVar("is_debugging_func", lambda: self._debugging)
+        self.set_sharedVar("in_transition", False)
         self.set_sharedVar("in_cutscene", False)
-        self.set_sharedVar("player_has_control", True)
 
         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,26 +23,28 @@ class SceneManager:
 
     def print_status(self):
         print("-" * 40)
-        print([(s._name, "Active" if s._active else "Inactive","Visible" if s._visible else "Invisible", f"index={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---")
-        for name, value in self._sharedVarDict.items():
+        _ = [
             print(f"[{str(name)} = {str(value)}]")
+            for name, value in self.sharedVarDict.items()
+        ]
         print("-" * 40)
 
     def set_sharedVar(self, name, value) -> bool:
-        self._sharedVarDict[name] = value
+        self.sharedVarDict[name] = value
         return True
 
-    def get_sharedVar(self, name,error_value=None):
-        if name not in self._sharedVarDict:
-            return error_value
-        return self._sharedVarDict[name]
-
-    def get_current_scene_name(self) -> str:
-        return self._scenes[0].get_name()
-
-    def get_current_scene(self) -> bf.Scene:
+    def get_sharedVar(self, name):
+        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:
         return self._scenes[0]
 
     def update_scene_states(self):
@@ -68,51 +71,79 @@ class SceneManager:
             if scene._name == name:
                 return scene
 
-    def get_scene_at(self,index:int)->bf.Scene|None:
-        if index < 0 or index >= len(self._scenes) : return None
-        return self._scenes[index]
-
     def transition_to_scene(self, dest_scene_name, transition, **kwargs):
-        self.set_scene(dest_scene_name)
+        if not self.has_scene(dest_scene_name):
+            return False
+        source_surf = pygame.Surface(bf.const.RESOLUTION,pygame.SRCALPHA).convert_alpha()
+        dest_surf = pygame.Surface(bf.const.RESOLUTION,pygame.SRCALPHA).convert_alpha()
+
+        index = kwargs.pop("index",0)
+        #draw the surfaces
+        source_scenes = [s for s in self.visible_scenes if s.scene_index >= index and s._visible]
+        # source_scenes = self.visible_scenes
+        _ = [s.draw(source_surf) for s in source_scenes] 
+        # self._scenes[index].draw(source_surf)
+
+        # pygame.image.save_extended:(source_surf,"source_surface.png")
+        self.get_scene(dest_scene_name).draw(dest_surf)
+        # pygame.image.save_extended(dest_surf,"dest_surface.png")
+
+        # print(f"start transition from {self._scenes[index]._name} to {dest_scene_name}")
+
+        instance: bf.BaseTransition = transition(
+            source_surf, dest_surf, **kwargs
+        )
+        instance.set_scene_index(index)
+        instance.set_source_name(self._scenes[index]._name)
+        instance.set_dest_name(dest_scene_name)
+        self.transitions.append(instance)
+        self.set_sharedVar("in_transition", True)
+
+    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
+
+        # print(f"switch from {old_scene._name} to  {target_scene._name} in index {index}")
+
+        #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):
+        if self.transitions:
+            return
         keys = pygame.key.get_pressed()
         if (
             keys[pygame.K_LCTRL]
             and event.type == pygame.KEYDOWN
             and event.key == pygame.K_d
         ):
-            self._debugging = (self._debugging + 1) % 4
-            self.set_sharedVar("debugging_mode",self._debugging)
+            self._debugging = (self._debugging + 1) % 3
             return
-        if (
+        elif (
             keys[pygame.K_LCTRL]
             and event.type == pygame.KEYDOWN
             and event.key == pygame.K_p
         ):
             self.print_status()
-            return
         self._scenes[0].process_event(event)
 
     def update(self, dt: float) -> None:
+        if self.transitions:
+            transition = self.transitions[0]
+            transition.update(dt)
+            if transition.has_ended():
+                self.set_sharedVar("in_transition", False)
+                self.set_scene(transition.dest_scene_name,transition.index)
+
+                self.transitions.pop(0)
+            return
         for scene in self.active_scenes:
             scene.update(dt)
         self.do_update(dt)
@@ -121,5 +152,14 @@ class SceneManager:
         return
 
     def draw(self, surface) -> None:
-        for scene in self.visible_scenes:
+        transition_scene_index = -1
+        visible_scenes = self.visible_scenes.copy()
+        if self.transitions:
+            transition_scene_index = self.transitions[0].index
+            
+        if transition_scene_index >=0:
+            self.transitions[0].draw(surface)
+            visible_scenes = [s  for s in visible_scenes if s.scene_index < transition_scene_index]
+
+        for scene in visible_scenes:
             scene.draw(surface)

batFramework/stateMachine.py

@@ -44,7 +44,6 @@ 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