batframework 1.0.9a6__py3-none-any.whl → 1.0.9a8__py3-none-any.whl

batFramework/scene.py

@@ -1,351 +1,31 @@
-from __future__ import annotations
-import re
-from collections import OrderedDict
-import itertools
-
-from typing import TYPE_CHECKING, Any
-if TYPE_CHECKING:
-    from .manager import Manager
-    from .sceneManager import SceneManager
-import pygame
+from .baseScene import BaseScene
 import batFramework as bf
 
 
-class Scene:
-    def __init__(
-        self,
-        name: str,
-        hud_convert_alpha: bool = True,
-        world_convert_alpha: bool = False,
-    ) -> None:
+class Scene(BaseScene):
+    def __init__(self,name: str) -> None:
         """
-        Initialize the Scene object.
-
+        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.
-            enable_alpha (bool, optional): Enable alpha channel for the scene surfaces. Defaults to True.
         """
-        self.scene_index = 0
-        self.name = name
-        bf.TimeManager().add_register(self.name,False)
-        self.manager: Manager | None = None
-        self.active = False
-        self.visible = False
-        self.world_entities: OrderedDict[bf.Entity, None] = OrderedDict()
-        self.hud_entities: OrderedDict[bf.Entity, None] = OrderedDict()
-        self.actions: bf.ActionContainer = bf.ActionContainer()
-        self.early_actions: bf.ActionContainer = bf.ActionContainer()
-        self.camera: bf.Camera = bf.Camera(convert_alpha=world_convert_alpha)
-        self.hud_camera: bf.Camera = bf.Camera(convert_alpha=hud_convert_alpha)
-        self.should_sort :bool = True
-        self.root: bf.Root = bf.Root(self.hud_camera)
-        self.root.rect.center = self.hud_camera.get_center()
-        self.add_hud_entity(self.root)
+        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 __str__(self)->str:
-        return f"Scene({self.name})"
-
-    def get_world_entity_count(self) -> int:
-        return len(self.world_entities)
-
-    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."""
-        self.scene_index = index
-
-    def get_scene_index(self) -> int:
-        """Get the scene index."""
-        return self.scene_index
-
-    def do_when_added(self):
-        pass
-
-    def set_clear_color(self, color: pygame.Color | tuple):
-        """Set the clear color for the camera."""
-        self.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()
-
-    def set_active(self, value):
-        """Set the activity of the scene."""
-        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
-
-    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, *entities: bf.Entity):
-        """Add world entities to the scene."""
-        change = False
-        for e in entities:
-            if e not in self.world_entities and e not in self.entities_to_add:
-                change = True
-                # self.world_entities[e] = None
-                self.entities_to_add.append(e)
-                e.set_parent_scene(self)
-        # self.sort_entities()
-        return change
-
-    # Updated remove_world_entity method to add entities to the removal list
-    def remove_world_entity(self, *entities: bf.Entity):
-        """Mark world entities for removal from the scene."""
-        change = False
-        for e in entities:
-            if e in self.world_entities:
-                change = True
-                self.entities_to_remove.append(e)
-                e.set_parent_scene(None)
-        return change
-
-    def add_hud_entity(self, *entities: bf.Entity):
-        """Add HUD entities to the scene."""
-        for e in entities:
-            if e not in self.hud_entities:
-                self.hud_entities[e] = None
-                e.set_parent_scene(self)
-        self.sort_entities()
-        return True
-
-    def remove_hud_entity(self, *entities: bf.Entity):
-        """Remove HUD entities from the scene."""
-        for e in entities:
-            if e in self.hud_entities:
-                e.set_parent_scene(None)
-                self.hud_entities.pop(e)
-
-    def add_actions(self, *action):
-        """Add actions to the scene."""
-        self.actions.add_actions(*action)
-
-    def add_early_actions(self, *action):
-        """Add actions to the scene."""
-        self.early_actions.add_actions(*action)
-
-    def get_by_tags(self, *tags):
-        """Get entities by their tags."""
-        res = [
-            entity
-            for entity in itertools.chain(
-                self.world_entities.keys(), self.hud_entities.keys()
-            )
-            if any(entity.has_tags(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, itertools.chain(self.world_entities.keys(), self.hud_entities.keys())
-        )
-        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
-
-    def process_event(self, event: pygame.Event):
-        """
-        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 event.consumed:
-            return
-        self.do_early_handle_event(event)
-        if event.consumed:
-            return
-        self.early_actions.process_event(event)
-        if event.consumed:
-            return
-        for entity in itertools.chain(
-            self.hud_entities.keys(), self.world_entities.keys()
-        ):
-            entity.process_event(event)
-            if event.consumed:
-                return
-        self.do_handle_event(event)
-        if event.consumed:
-            return
-        self.actions.process_event(event)
-
-    # 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):
-        """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"""
-        if self.should_sort:
-            self._sort_entities_internal()
-
-        for entity in itertools.chain(
-            self.hud_entities.keys(), self.world_entities.keys()
-        ):
-            entity.update(dt)
-        
-        self.do_update(dt)
-        self.camera.update(dt)
-        self.hud_camera.update(dt)
-        self.actions.reset()
-        self.early_actions.reset()
-
-        if self.entities_to_add:
-            for e in self.entities_to_add:
-                self.world_entities[e] = None
-            self.entities_to_add.clear()
-
-        # Remove marked entities after updating
-        if self.entities_to_remove:
-            for e in self.entities_to_remove:
-                self.world_entities.pop(e, None)
-            self.entities_to_remove.clear()
-
-    def do_update(self, dt):
-        """Specific update within the scene."""
-        pass
-
-    def debug_entity(self, entity: bf.Entity, camera: bf.Camera):
-        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)
-
-        [draw_rect(data) for data in entity.get_debug_outlines()]
-
-    def sort_entities(self) -> None:
-        self.should_sort = True
-
-    def _sort_entities_internal(self):
-        """Sort entities within the scene based on their rendering order."""
-        self.world_entities = OrderedDict(
-            sorted(self.world_entities.items(), key=lambda e: e[0].render_order)
-        )
-        self.hud_entities = OrderedDict(
-            sorted(self.hud_entities.items(), key=lambda e: e[0].render_order)
-        )
-        self.should_sort = False
-
-    def draw(self, surface: pygame.Surface):
-        self.camera.clear()
-        self.hud_camera.clear()
-
-        # Draw all world entities
-        self._draw_camera(self.camera, self.world_entities.keys())
-        # Draw all HUD entities
-        self._draw_camera(self.hud_camera, self.hud_entities.keys())
-
-        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)
-
-    def _draw_camera(self, camera: bf.Camera, entity_list):
-        _ = [entity.draw(camera) for entity in entity_list]
-        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]
-
-    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)
         self.root.clear_hovered()
         self.root.build()
-        bf.TimeManager().activate_register(self.name)
-        self.do_on_enter()
+        super().on_enter()
 
     def on_exit(self):
         self.root.clear_hovered()
-        self.set_active(False)
-        self.set_visible(False)
-        self.actions.hard_reset()
-        self.early_actions.hard_reset()
-        bf.TimeManager().deactivate_register(self.name)
-        self.do_on_exit()
-
-    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_early(self) -> None:
-        pass
+        super().on_exit()

batFramework/sceneLayer.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+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
+    One common use would be to separate GUI and game into two separate layers
+    """
+    def __init__(self,name:str,convert_alpha:bool = False):
+        self.scene = None
+        self.name = name
+        self.entities : dict[int,Entity] = {}
+        self.entities_to_add : set[Entity]= set()
+        self.entities_to_remove : set[Entity]= set()
+        self.draw_order : list[int] = []
+        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 event.type == pygame.VIDEORESIZE:
+            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 clear(self):
+        """
+        Clear the camera surface
+        """
+        self.camera.clear()
+
+    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]
+
+        # Blit the camera surface onto the provided surface
+        # surface.blit(self.camera.surface, (0, 0))
+        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):
+                pygame.draw.rect(self.camera.surface, color, self.camera.world_to_screen(rect), 1)
+
+        for data in entity.get_debug_outlines():
+            draw_rect(data)

batFramework/sceneManager.py

@@ -8,9 +8,9 @@ def swap(lst, index1, index2):
 
 class SceneManager:
     def __init__(self) -> None:
-        self.scenes: list[bf.Scene] = []
+        self.scenes: list[bf.BaseScene] = []
         self.shared_events = {pygame.WINDOWRESIZED}
-        self.current_transitions: dict[str, bf.transition.Transition] = {}
+        self.current_transition : tuple[str,bf.transition.Transition,int] | None= None
 
     def init_scenes(self, *initial_scenes:bf.Scene):
         for index, s in enumerate(initial_scenes):
@@ -56,7 +56,7 @@ class SceneManager:
         print("\n" + "=" * 50)
         print(" DEBUGGING STATUS".center(50))
         print("=" * 50)
-        print(f"[Debugging Mode] = {self.debug_mode}")
+        print(f"[Debugging Mode] = {bf.ResourceManager().get_sharedVar("debug_mode")}")
 
         # Print shared variables
         print("\n" + "=" * 50)
@@ -86,7 +86,7 @@ class SceneManager:
         if scene in self.scenes and not self.has_scene(scene.name):
             return
         scene.set_manager(self)
-        scene.do_when_added()
+        scene.when_added()
         self.scenes.insert(0, scene)
 
     def remove_scene(self, name: str):
@@ -110,36 +110,34 @@ class SceneManager:
     def transition_to_scene(
         self,
         scene_name: str,
-        transition: bf.transition.Transition = bf.transition.Fade(0.1),
+        transition: bf.transition.Transition = None,
         index: int = 0,
     ):
-        target_scene = self.get_scene(scene_name)
-        if not target_scene:
+        if transition is None:
+            transition = bf.transition.Fade(0.1)
+        if not (target_scene := self.get_scene(scene_name)):
             print(f"Scene '{scene_name}' does not exist")
             return
-        if len(self.scenes) == 0 or index >= len(self.scenes) or index < 0:
-            return
+        if not (source_scene := self.get_scene_at(index)):
+            print(f"No scene exists at index {index}.")
+            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))
+        target_scene.draw(dest_surface) # draw at least once to ensure smooth transition
+        target_scene.set_active(True)
+        target_scene.set_visible(True)
+
+        target_scene.do_on_enter_early() 
+        source_scene.do_on_exit_early()
+
+        self.current_transition :tuple[str,bf.transition.Transition]=(scene_name,transition,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)
 
-    def _end_transition(self, scene_name, index):
-        self.set_scene(scene_name, index, True)
-        self.current_transitions.clear()
 
     def set_scene(self, scene_name, index=0, ignore_early: bool = False):
         target_scene = self.get_scene(scene_name)
@@ -171,9 +169,6 @@ class SceneManager:
 
     def process_event(self, event: pygame.Event):
 
-        if self.current_transitions and event in bf.enums.playerInput:
-            return
-
         if event.type in self.shared_events:
             [s.process_event(event) for s in self.scenes]
         else:
@@ -182,21 +177,21 @@ class SceneManager:
     def update(self, dt: float) -> None:
         for scene in self.active_scenes:
             scene.update(dt)
+        if self.current_transition and self.current_transition[1].is_over:
+            self.set_scene(self.current_transition[0],self.current_transition[2],True)
+            self.current_transition = None
         self.do_update(dt)
 
     def do_update(self, dt: float):
         pass
 
-    def draw(self, surface) -> None:
+    def draw(self, surface:pygame.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
+        if self.current_transition is not None:
+            self.current_transition[1].set_source(surface)
+            tmp = surface.copy()
+            self.get_scene(self.current_transition[0]).draw(tmp)
+            self.current_transition[1].set_dest(tmp)
+            self.current_transition[1].draw(surface)
+

batFramework/scrollingSprite.py

@@ -66,7 +66,7 @@ class ScrollingSprite(bf.Sprite):
         self.rect = self.surface.get_frect(topleft=self.rect.topleft)
         return self
 
-    def _get_mosaic_rect_list(self) -> Iterator[pygame.Rect]:
+    def _get_mosaic_rect_list(self,camera:bf.Camera=None) -> Iterator[pygame.Rect]:
         # Use integer values for the starting points, converted from floating point scroll values
         start_x = int(self.scroll_value.x % self.original_width)
         start_y = int(self.scroll_value.y % self.original_height)
@@ -90,7 +90,12 @@ class ScrollingSprite(bf.Sprite):
         while x < end_x:
             y = y_position
             while y < end_y:
-                yield pygame.Rect(x, y, self.original_width, self.original_height)
+                r = pygame.Rect(x, y, self.original_width, self.original_height)
+                
+                if camera and camera.rect.colliderect((x+camera.rect.x,y+camera.rect.y,self.original_width,self.original_height)):
+                    yield r
+                else:
+                    yield r
                 y += self.original_height
             x += self.original_width
         return self
@@ -104,7 +109,7 @@ class ScrollingSprite(bf.Sprite):
             return
         # self.surface.fill((0, 0, 0, 0))
         camera.surface.fblits(
-            [(self.original_surface, r.move(self.rect.x-camera.rect.x,self.rect.y-camera.rect.y)) for r in self._get_mosaic_rect_list()]
+            [(self.original_surface, r.move(self.rect.x-camera.rect.x,self.rect.y-camera.rect.y)) for r in self._get_mosaic_rect_list(camera)]
         )
         # camera.surface.blit(self.surface, camera.world_to_screen(self.rect))
         return

batFramework/sprite.py

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

batFramework/templates/__init__.py

@@ -1,2 +1 @@
-from .character import *
-from .states import *
+from .controller import *