batframework 1.0.6__py3-none-any.whl → 1.0.8a1__py3-none-any.whl

batFramework/scene.py

@@ -10,7 +10,12 @@ import batFramework as bf
 
 
 class Scene:
-    def __init__(self, name: str, enable_alpha: bool = True) -> None:
+    def __init__(
+        self,
+        name: str,
+        hud_convert_alpha: bool = True,
+        world_convert_alpha: bool = False,
+    ) -> None:
         """
         Initialize the Scene object.
 
@@ -19,30 +24,32 @@ class Scene:
             enable_alpha (bool, optional): Enable alpha channel for the scene surfaces. Defaults to True.
         """
         self.scene_index = 0
-        self._name = name
+        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.active = False
+        self.visible = False
+        self.world_entities: list[bf.Entity] = []
+        self.hud_entities: list[bf.Entity] = []
         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(convert_alpha=world_convert_alpha)
+        self.hud_camera: bf.Camera = bf.Camera(convert_alpha=hud_convert_alpha)
 
         self.root: bf.Root = bf.Root(self.hud_camera)
-        self.root.set_center(*self.hud_camera.get_center())
+        self.root.rect.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_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 get_hud_entity_count(self) -> int:
+        n = 0
+        def adder(e):
+            nonlocal n
+            n += len(e.children)
+        self.root.visit(adder)
 
+        return len(self.hud_entities) + n 
 
     def set_scene_index(self, index: int):
         """Set the scene index."""
@@ -67,7 +74,7 @@ class Scene:
             return False
         return self.manager.set_sharedVar(name, value)
 
-    def get_sharedVar(self, name: str,error_value=None) -> Any:
+    def get_sharedVar(self, name: str, error_value=None) -> Any:
         """
         Get a shared variable from the manager.
 
@@ -79,7 +86,7 @@ class Scene:
         """
         if not self.manager:
             return error_value
-        return self.manager.get_sharedVar(name,error_value)
+        return self.manager.get_sharedVar(name, error_value)
 
     def do_when_added(self):
         pass
@@ -95,32 +102,32 @@ class Scene:
 
     def set_visible(self, value: bool):
         """Set the visibility of the scene."""
-        self._visible = value
+        self.visible = value
         if self.manager:
             self.manager.update_scene_states()
 
     def set_active(self, value):
         """Set the activity of the scene."""
-        self._active = value
+        self.active = value
         if self.manager:
             self.manager.update_scene_states()
 
     def is_active(self) -> bool:
         """Check if the scene is active."""
-        return self._active
+        return self.active
 
     def is_visible(self) -> bool:
         """Check if the scene is visible."""
-        return self._visible
+        return self.visible
 
     def get_name(self) -> str:
         """Get the name of the scene."""
-        return self._name
+        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)
+            self.world_entities.append(e)
             e.parent_scene = self
             e.do_when_added()
         self.sort_entities()
@@ -128,17 +135,17 @@ class Scene:
     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:
+            if e not in self.world_entities:
                 return False
             e.do_when_removed()
             e.parent_scene = None
-            self._world_entities.remove(e)
+            self.world_entities.remove(e)
             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)
+            self.hud_entities.append(e)
             e.parent_scene = self
             e.do_when_added()
         self.sort_entities()
@@ -147,24 +154,24 @@ class Scene:
     def remove_hud_entity(self, *entity: bf.Entity):
         """Remove HUD entities from the scene."""
         for e in entity:
-            if e in self._hud_entities:
+            if e in self.hud_entities:
                 e.do_when_removed()
                 e.parent_scene = None
-                self._hud_entities.remove(e)
+                self.hud_entities.remove(e)
 
     def add_actions(self, *action):
         """Add actions to the scene."""
-        self.actions.add_action(*action)
+        self.actions.add_actions(*action)
 
     def add_early_actions(self, *action):
         """Add actions to the scene."""
-        self.early_actions.add_action(*action)
+        self.early_actions.add_actions(*action)
 
     def get_by_tags(self, *tags):
         """Get entities by their tags."""
         res = [
             entity
-            for entity in self._world_entities + self._hud_entities
+            for entity in self.world_entities + self.hud_entities
             if any(entity.has_tags(t) for t in tags)
         ]
         res.extend(list(self.root.get_by_tags(*tags)))
@@ -172,7 +179,7 @@ class Scene:
 
     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)
+        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
@@ -193,34 +200,36 @@ class Scene:
             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:
-        """return True if stop event propagation in child entities and scene's action container"""
-        return False
+        return None
 
     # propagates event to all entities
     def process_event(self, event: pygame.Event):
         """
-        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.
+        Propagates event while it is not consumed.
+        In order : 
+        -do_early_handle_event()
+        -scene early_actions
+        -propagate to scene entities (hud then world)
+        -do_handle_event()
+        -scene actions
+        at each step, if the event is consumed the propagation stops
         """
-
-        if self.do_early_process_event(event):
-            return
+        if event.consumed : return
+        self.do_early_handle_event(event)
+        if event.consumed : return
         self.early_actions.process_event(event)
-        self.do_handle_actions()
+        if event.consumed : return
+        for entity in self.hud_entities + self.world_entities:
+            entity.process_event(event)
+            if event.consumed : return    
         self.do_handle_event(event)
-        for entity in self._hud_entities + self._world_entities:
-            if entity.process_event(event):
-                return
+        if event.consumed : return
         self.actions.process_event(event)
 
-
-    def do_handle_actions(self) -> None:
-        """Handle actions within the scene."""
+    # called before process event
+    def do_early_handle_event(self, event: pygame.Event) :
+        """Called early in event propagation"""
         pass
 
     def do_handle_event(self, event: pygame.Event):
@@ -229,7 +238,7 @@ class Scene:
 
     def update(self, dt):
         """Update the scene. Do NOT override"""
-        for entity in self._world_entities + self._hud_entities:
+        for entity in self.world_entities + self.hud_entities:
             entity.update(dt)
         self.do_update(dt)
         self.camera.update(dt)
@@ -242,57 +251,47 @@ class Scene:
         pass
 
     def debug_entity(self, entity: bf.Entity, camera: bf.Camera):
-        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):
+        def draw_rect(data):
+            if data is None:
+                return
+            if isinstance(data, pygame.FRect) or isinstance(data, pygame.Rect):
                 rect = data
                 color = entity.debug_color
             else:
                 rect = data[0]
                 color = data[1]
+            pygame.draw.rect(camera.surface, color, camera.world_to_screen(rect), 1)
 
-            pygame.draw.rect(camera.surface, color, camera.transpose(rect), 1)
+        [draw_rect(data) for data in entity.get_debug_outlines()]
 
     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()
+        self.world_entities.sort(key=lambda e: e.render_order)
+        self.hud_entities.sort(key=lambda e: e.render_order)
 
-        show_outlines = self.manager._debugging in [2, 3]
-        show_only_visible_outlines = self.manager._debugging != 3
+    def _draw_camera(self, camera: bf.Camera, entity_list: list[bf.Entity]) ->None:
+        _ = [entity.draw(camera) for entity in entity_list]
+        debugMode = self.manager.debug_mode
+        # Draw outlines for world entities if required
+        if debugMode == bf.debugMode.OUTLINES:
+            [self.debug_entity(e, camera) for e in entity_list]
 
 
-        #   draw all 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)]
+    def draw(self, surface: pygame.Surface):
 
-        total_blit_calls += sum(entity.draw(self.hud_camera) for entity in self._hud_entities)
+        self.camera.clear()
+        self.hud_camera.clear()
 
-        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)]
+        # Draw all world entities
+        self._draw_camera(self.camera, self.world_entities)
+        # Draw all HUD entities
+        self._draw_camera(self.hud_camera, self.hud_entities)
 
         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):
         pass
@@ -307,21 +306,28 @@ class Scene:
         self.set_active(True)
         self.set_visible(True)
         self.root.clear_hovered()
-        self.root.clear_focused()
+        # self.root.clear_focused()
         self.root.build()
         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.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:
+    def do_on_enter(self) -> None:
+        pass
+
+    def do_on_exit(self) -> None:
+        pass
+
+    def do_on_enter_early(self) -> None:
         pass
 
-    def do_on_exit(self)->None:
+    def do_on_exit_early(self) -> None:
         pass

batFramework/sceneManager.py

@@ -1,116 +1,189 @@
 import batFramework as bf
 import pygame
+from typing import Self
+
+def swap(lst, index1, index2):
+    lst[index1], lst[index2] = lst[index2], lst[index1]
 
 
 class SceneManager:
-    def __init__(self, *initial_scenes: bf.Scene) -> None:
-        self._debugging :int = 0
-        self._sharedVarDict : dict = {}
+    def __init__(self) -> None:
+        self.scenes: list[bf.Scene] = []
+        self.shared_variables: dict = {}
+        self.shared_events = {pygame.WINDOWRESIZED}
 
-        self._scene_transitions: list = []
-        self.set_sharedVar("debugging_mode",self._debugging)
         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):
-            s.set_manager(self)
+        self.debug_mode: bf.enums.debugMode = bf.debugMode.HIDDEN
+        self.current_transitions: dict[str, bf.transition.Transition] = {}
+
+
+
+    def init_scenes(self,*initial_scenes):
+        for index, s in enumerate(initial_scenes):
             s.set_scene_index(index)
-            s.do_when_added()
-        self.set_scene(self._scenes[0]._name)
+        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()
 
+    def set_shared_event(self,event:pygame.Event)->None:
+        """
+        Add an event that will be propagated to all active scenes, not just the one on top.
+        """
+        self.shared_events.add(event)
+
     def print_status(self):
+        """
+        Print some information about the current state of the scenes.
+        """
         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(f"[Debugging] = {self._debugging}")
+        print(
+            '\n'.join(
+                f" {s.name:<30}\t{'Active' if s.active else 'Inactive'}\t{'Visible' if s.visible else 'Invisible'}\tindex= {s.scene_index}"
+                for s in self.scenes
+            )
+        )
+        print(f"[Debugging] = {self.debug_mode}")
         print("---SHARED VARIABLES---")
-        for name, value in self._sharedVarDict.items():
+        for name, value in self.shared_variables.items():
             print(f"[{str(name)} = {str(value)}]")
         print("-" * 40)
 
     def set_sharedVar(self, name, value) -> bool:
-        self._sharedVarDict[name] = value
+        """
+        Set a shared variable of any type. This will be accessible (read/write) from any scene
+        """
+        self.shared_variables[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_sharedVar(self, name, error_value=None):
+        """
+        Get a shared variable
+        """
+        return self.shared_variables.get(name,error_value)
 
     def get_current_scene_name(self) -> str:
-        return self._scenes[0].get_name()
+        """get the name of the current scene"""
+        return self.scenes[0].get_name()
 
     def get_current_scene(self) -> bf.Scene:
-        return self._scenes[0]
+        return self.scenes[0]
 
     def update_scene_states(self):
-        self.active_scenes = [s for s in reversed(self._scenes) if s._active]
-        self.visible_scenes = [s for s in reversed(self._scenes) if s._visible]
+        self.active_scenes = [s for s in reversed(self.scenes) if s.active]
+        self.visible_scenes = [s for s in reversed(self.scenes) if s.visible]
 
     def add_scene(self, scene: bf.Scene):
-        if scene in self._scenes and not self.has_scene(scene._name):
+        if scene in self.scenes and not self.has_scene(scene.name):
             return
         scene.set_manager(self)
         scene.do_when_added()
-        self._scenes.insert(0, scene)
+        self.scenes.insert(0, scene)
 
     def remove_scene(self, name: str):
-        self._scenes = [s for s in self._scenes if s._name != name]
+        self.scenes = [s for s in self.scenes if s.name != name]
 
     def has_scene(self, name):
-        return any(name == scene._name for scene in self._scenes)
+        return any(name == scene.name for scene in self.scenes)
 
     def get_scene(self, name):
         if not self.has_scene(name):
             return None
-        for scene in self._scenes:
-            if scene._name == name:
+        for scene in self.scenes:
+            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)
+    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,
+        scene_name: str,
+        transition: bf.transition.Transition = bf.transition.Fade(0.1),
+        index: int = 0,
+    ):
+        target_scene = self.get_scene(scene_name)
+        if not target_scene : 
+            print(f"Scene '{scene_name}' does not exist")
+            return
+        if (
+            len(self.scenes) == 0
+            or index >= len(self.scenes)
+            or index < 0
+        ):
+            return
+        source_surface = bf.const.SCREEN.copy()
+        dest_surface = bf.const.SCREEN.copy()
+
+        # self.draw(source_surface)
+        target_scene.draw(dest_surface)
+        target_scene.do_on_enter_early()
+        self.get_scene_at(index).do_on_exit_early()
+        self.current_transitions = {"scene_name": scene_name, "transition": transition}
+        transition.set_start_callback(lambda: self._start_transition(target_scene))
+        transition.set_end_callback(lambda: self._end_transition(scene_name, index))
+        transition.set_source(source_surface)
+        transition.set_dest(dest_surface)
+        transition.start()
+
+    def _start_transition(self, target_scene: bf.Scene):
+        target_scene.set_active(True)
+        target_scene.set_visible(True)
+        self.set_sharedVar("player_has_control", False)
+
+    def _end_transition(self, scene_name, index):
+        self.set_scene(scene_name, index)
+        self.set_sharedVar("player_has_control", True)
+        self.current_transitions.clear()
 
-    def set_scene(self, name, index=0):
-        target_scene = self.get_scene(name)
+    def set_scene(self, scene_name, index=0):
+        target_scene = self.get_scene(scene_name)
+        if not target_scene : 
+            print(f"'{scene_name}' does not exist")
+            return
         if (
-            len(self._scenes) == 0
-            or not target_scene
-            or index >= len(self._scenes)
+            len(self.scenes) == 0
+            or index >= len(self.scenes)
             or index < 0
         ):
             return
 
-        old_scene = self._scenes[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[index].on_exit()
+        # re-insert scene at index 0
+        self.scenes.remove(target_scene)
+        self.scenes.insert(index, target_scene)
+        _ = [s.set_scene_index(i) for i, s in enumerate(self.scenes)]
         target_scene.on_enter()
 
+    def cycle_debug_mode(self):
+        current_index = self.debug_mode.value
+        next_index = (current_index + 1) % len(bf.debugMode)
+        return bf.debugMode(next_index)
+
     def process_event(self, event: pygame.Event):
         keys = pygame.key.get_pressed()
         if (
             keys[pygame.K_LCTRL]
+            and keys[pygame.K_LSHIFT]
             and event.type == pygame.KEYDOWN
-            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]
-            and event.type == pygame.KEYDOWN
-            and event.key == pygame.K_p
-        ):
-            self.print_status()
-            return
-        self._scenes[0].process_event(event)
+            if event.key == pygame.K_d:
+                self.debug_mode = self.cycle_debug_mode()
+                self.set_sharedVar("debug_mode", self.debug_mode)
+                return
+            if event.key == pygame.K_p:
+                self.print_status()
+                return
+        if event.type in self.shared_events:
+            [s.process_event(event) for s in self.scenes]
+        else:
+            self.scenes[0].process_event(event)
 
     def update(self, dt: float) -> None:
         for scene in self.active_scenes:
@@ -118,8 +191,18 @@ class SceneManager:
         self.do_update(dt)
 
     def do_update(self, dt: float):
-        return
+        pass
 
     def draw(self, surface) -> None:
         for scene in self.visible_scenes:
             scene.draw(surface)
+        if self.current_transitions:
+            self._draw_transition(surface)
+
+    def _draw_transition(self, surface):
+        self.current_transitions["transition"].set_source(surface)
+        tmp = bf.const.SCREEN.copy()
+        self.get_scene(self.current_transitions["scene_name"]).draw(tmp)
+        self.current_transitions["transition"].set_dest(tmp)
+        self.current_transitions["transition"].draw(surface)
+        return