batframework 1.0.10__py3-none-any.whl → 2.0.0__py3-none-any.whl

batFramework/scene.py

@@ -1,226 +1,31 @@
-from __future__ import annotations
-import re
-from typing import TYPE_CHECKING,Any
-if TYPE_CHECKING:
-    from .manager import Manager
-import pygame
-import batFramework as bf
-
-
-class Scene:
-    def __init__(self, name, enable_alpha=True) -> None:
-        self._name = name
-        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.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.root.set_center(*self.hud_camera.get_center())
-        self.add_hud_entity(self.root)
-        self.blit_calls = 0
-
-    def set_scene_index(self,index):
-        self.scene_index = index
-
-    def get_scene_index(self):
-        return self.scene_index
-
-    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)->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):
-        self.camera.set_clear_color(color)
-        # self.hud_camera.set_clear_color(color)
-
-    def set_manager(self, manager_link: Manager):
-        self.manager = manager_link
-
-    def set_visible(self, value: bool):
-        self._visible = value
-        if self.manager : self.manager.update_scene_states()
-
-    def set_active(self, value):
-        self._active = value
-        if self.manager : self.manager.update_scene_states()
-
-    def is_active(self) -> bool:
-        return self._active
-
-    def is_visible(self) -> bool:
-        return self._visible
-
-    def get_name(self) -> str:
-        return self._name
-
-    def add_world_entity(self, *entity: bf.Entity):
-        for e in entity:
-            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):
-        for e in entity:
-            if e not in self._world_entities:
-                return False
-            e.do_when_removed()
-            e.parent_scene = None
-            self._world_entities.remove(e)
-            return True
-
-    def add_hud_entity(self, *entity: bf.Entity):
-        for e in entity:
-            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):
-        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_action(self, *action):
-        self.actions.add_action(*action)
-
-    def get_by_tags(self, *tags):
-        return [
-            entity
-            for entity in self._world_entities + self._hud_entities
-            if any(entity.has_tag(t) for t in tags)
-        ]
-
-    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,
-        )
-
-    # 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
-
-    # 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.
-        """
-        if self.get_sharedVar("in_transition"):
-            return
-        if self.do_early_process_event(event):
-            return
-        self.actions.process_event(event)
-        self.do_handle_event(event)
-        for entity in self._world_entities + self._hud_entities:
-            if entity.process_event(event):
-                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):
-        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)
-
-    def do_update(self, dt):
-        pass
-
-    def debug_entity(self, entity: bf.Entity, camera: bf.Camera):
-        # return
-        if not entity.visible:
-            return
-        for data in entity.get_bounding_box():
-            if isinstance(data,pygame.FRect):
-                rect = data
-                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 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
-        self.camera.clear()
-        self.hud_camera.clear()
-
-
-        total_blit_calls += sum(
-            entity.draw(self.camera) for entity in self._world_entities
-        )
-
-        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
-        )
-        if  self.manager and  self.manager._debugging == 2:
-            for entity in self._hud_entities:
-                self.debug_entity(entity, self.hud_camera)
-
-
-        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
-
-    def do_post_world_draw(self, surface: pygame.Surface):
-        pass
-
-    def do_final_draw(self, surface: pygame.Surface):
-        pass
-
-    def on_enter(self):
-        self.set_active(True)
-        self.set_visible(True)
-
-    def on_exit(self):
-        self.set_active(False)
-        self.set_visible(False)
-        self.actions.hard_reset()
+from .baseScene import BaseScene
+import batFramework as bf
+
+
+class Scene(BaseScene):
+    def __init__(self,name: str) -> None:
+        """
+        Default Scene object.
+        Has 2 layers (world and hud) by default
+        Contains an exposed root gui object on the hud layer
+        Args:
+            name: Name of the scene.
+        """
+        super().__init__(name)
+        self.add_layer(bf.SceneLayer("world",True))
+        hud_layer = bf.SceneLayer("hud",True)
+        self.add_layer(hud_layer)
+        self.root: bf.gui.Root = bf.gui.Root(hud_layer.camera)
+        self.root.rect.center = hud_layer.camera.get_center()
+        self.add("hud",self.root)
+        self.entities_to_remove = []
+        self.entities_to_add = []
+
+    def on_enter(self):
+        self.root.clear_hovered()
+        self.root.build()
+        super().on_enter()
+
+    def on_exit(self):
+        self.root.clear_hovered()
+        super().on_exit()

batFramework/sceneLayer.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+import math
+import batFramework as bf
+import pygame
+from .entity import Entity
+from .drawable import Drawable
+
+from typing import TYPE_CHECKING, Any
+if TYPE_CHECKING:
+    from .baseScene import BaseScene 
+
+class SceneLayer:
+    """
+    A scene layer is a 'dimension' bound to a scene
+    Each layer contains its own entities and camera
+    Allows sorting out  different types of content in a single scene 
+    One common use would be to separate GUI and game into two separate layers
+    Entities are drawn only if they inherit the Drawable class and are not in a RenderGroup
+    """
+    def __init__(self,name:str,convert_alpha:bool = False):
+        self.scene = None
+        self.name = name
+        self.entities : dict[int,Entity] = {} # contains all scene entities : key is uid
+        self.entities_to_add : set[Entity]= set() # entities to add to the scene, (1 frame delay after calling add)
+        self.entities_to_remove : set[Entity]= set() # entities to remove from the scene 
+        self.draw_order : list[int] = [] # stores the uid of entities to draw (in draw order)
+        self.camera = bf.Camera(convert_alpha=convert_alpha)
+
+    def set_clear_color(self,color):
+        self.camera.set_clear_color(color)
+
+    def set_scene(self, scene:BaseScene):
+        self.scene = scene
+
+    def add(self,*entities:Entity):
+        for e in entities:
+            if e.uid not in self.entities and e not in self.entities_to_add:
+                self.entities_to_add.add(e)
+
+
+    def get_by_tags(self,*tags)->list[Entity]:
+        return [v for v in self.entities.values() if v.has_tags(*tags) ]
+
+    def get_by_uid(self,uid:int)->Entity|None:
+        return self.entities.get(uid,None)
+
+    def remove(self,*entities:Entity):
+        for e in entities:
+            if e.uid in self.entities and e not in self.entities_to_remove:
+                self.entities_to_remove.add(e)
+
+    def process_event(self,event:pygame.Event):
+        if self.camera.fullscreen and event.type == pygame.VIDEORESIZE and not pygame.SCALED & bf.const.FLAGS:
+            self.camera.set_size(bf.const.RESOLUTION)
+
+        for e in self.entities.values():
+            e.process_event(event)
+            if event.consumed : return
+
+    def update(self, dt):
+        # Update all entities
+        for e in self.entities.values():
+            e.update(dt)
+
+        self.flush_entity_changes()
+
+        # Update the camera
+        self.camera.update(dt)
+
+    def flush_entity_changes(self):
+        """
+        Synchronizes entity changes by removing entities marked for removal,
+        adding new entities, and updating the draw order if necessary.
+        """
+        # Remove entities marked for removal
+        for e in self.entities_to_remove:
+            if e.uid in self.entities.keys():
+                e.set_parent_scene(None)
+                self.entities.pop(e.uid)
+        self.entities_to_remove.clear()
+
+        # Add new entities
+        reorder = False
+        for e in self.entities_to_add:
+            self.entities[e.uid] = e
+            e.set_parent_layer(self)
+            e.set_parent_scene(self.scene)
+            if not reorder and isinstance(e, Drawable):
+                reorder = True
+        self.entities_to_add.clear()
+
+        # Reorder draw order if necessary
+        if reorder:
+            self.update_draw_order()
+
+
+    def draw(self, surface: pygame.Surface):
+        self.camera.clear()
+        debugMode = bf.ResourceManager().get_sharedVar("debug_mode")
+        # Draw entities in the correct order
+        for uid in self.draw_order:
+            if uid in self.entities and not self.entities[uid].drawn_by_group:  # Ensure the entity still exists
+                self.entities[uid].draw(self.camera)
+
+        # Draw debug outlines if in debug mode
+        if debugMode == bf.debugMode.OUTLINES:
+            [self.debug_entity(uid) for uid in self.draw_order if uid in self.entities]
+
+        # surface.fill("white")
+        self.camera.draw(surface)
+
+    def update_draw_order(self):
+        self.draw_order = sorted(
+            (k for k,v in self.entities.items() if isinstance(v,Drawable) and not v.drawn_by_group),
+            key= lambda uid : self.entities[uid].render_order
+        )
+
+    def debug_entity(self, uid: int):
+        entity = self.entities[uid]
+        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]
+            if self.camera.intersects(rect):
+                line_width = 1 if self.camera.zoom_factor >= 1 else int(-math.log2(self.camera.zoom_factor)) + 2
+                pygame.draw.rect(self.camera.surface, color, self.camera.world_to_screen(rect), line_width )
+
+        for data in entity.get_debug_outlines():
+            draw_rect(data)