batframework 1.0.8a1__py3-none-any.whl → 1.0.8a2__py3-none-any.whl

batFramework/particles.py

@@ -0,0 +1,77 @@
+import batFramework as bf
+import pygame
+from pygame.math import Vector2
+
+
+class Particle:
+    def __init__(
+        self,
+        start_pos: tuple[float, float],
+        start_vel: tuple[float, float],
+        duration=1000,
+        color=None,
+        size = (4,4)
+    ):
+        self.rect = pygame.FRect(*start_pos, 0, 0)
+        self.surface = pygame.Surface(size).convert()
+        if color:
+            self.surface.fill(color)
+        self.velocity = Vector2(*start_vel)
+        self.start_time = pygame.time.get_ticks()
+        self.duration = duration
+        self.dead = False
+        self.progression = 0
+        self.z_depth = 1
+
+    def update(self, dt):
+        if self.dead:
+            return
+        elapsed_time = pygame.time.get_ticks() - self.start_time
+        self.progression = elapsed_time / self.duration
+        self.dead = elapsed_time >= self.duration
+        self.rect.center += self.velocity * dt
+        self.update_surface()
+
+    def kill(self):
+        self.dead = True
+
+    def update_surface(self):
+        self.surface.set_alpha(255 - int(self.progression * 255))
+
+
+class ParticleManager(bf.Entity):
+    def __init__(self) -> None:
+        super().__init__(size=bf.const.RESOLUTION)
+        self.particles: list[Particle] = []
+
+    def get_bounding_box(self):
+        for particle in self.particles:
+            yield particle.rect
+
+    def add_particle(self, particle_class=Particle, **kwargs):
+        self.particles.append(particle_class(**kwargs))
+
+
+    def clear(self):
+        self.particles = []
+        
+
+    def update(self, dt: float):
+        particles_to_remove = []
+        for particle in self.particles:
+            particle.update(dt)
+            if particle.dead:
+                particles_to_remove.append(particle)
+        for p in particles_to_remove:
+            self.particles.remove(p)
+
+    def draw(self, camera) -> bool:
+        camera.surface.fblits(
+            [
+                (
+                    p.surface,
+                    tuple(round(i * self.z_depth) for i in camera.transpose(self.rect).topleft)
+                ) for p in self.particles
+            ]
+        )
+        return len(self.particles)

batFramework/scene.py

@@ -1,291 +1,203 @@
 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,
-        hud_convert_alpha: bool = True,
-        world_convert_alpha: bool = False,
-    ) -> 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
-        self.name = name
+    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.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=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.rect.center = self.hud_camera.get_center()
-        self.add_hud_entity(self.root)
-
-    def get_world_entity_count(self) -> int:
-        return len(self.world_entities)
+        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()
 
-    def get_hud_entity_count(self) -> int:
-        n = 0
-        def adder(e):
-            nonlocal n
-            n += len(e.children)
-        self.root.visit(adder)
+            self.camera.set_clear_color((0, 0, 0))
+            self.hud_camera.set_clear_color((0, 0, 0, 0))
 
-        return len(self.hud_entities) + n 
+        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: 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()
+        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()
+        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)
-            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:
+            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)
-            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:
+            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."""
-        self.actions.add_actions(*action)
+                self._hud_entities.remove(e)
 
-    def add_early_actions(self, *action):
-        """Add actions to the scene."""
-        self.early_actions.add_actions(*action)
+    def add_action(self, *action):
+        self.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)
+            for entity in self._world_entities + self._hud_entities
+            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:
+        """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 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
+        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 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 self.hud_entities + self.world_entities:
-            entity.process_event(event)
-            if event.consumed : return    
-        self.do_handle_event(event)
-        if event.consumed : return
+        if self.get_sharedVar("in_transition"):
+            return
+        if self.do_early_process_event(event):
+            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
+        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):
-        """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)
         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):
-        def draw_rect(data):
-            if data is None:
-                return
-            if isinstance(data, pygame.FRect) or isinstance(data, pygame.Rect):
+        # return
+        if not entity.visible:
+            return
+        for data in entity.get_bounding_box():
+            if isinstance(data,pygame.FRect):
                 rect = data
-                color = entity.debug_color
+                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:
-        """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_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]
+            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()
 
-        # 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)
+
+        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)
@@ -293,6 +205,8 @@ class Scene:
         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
 
@@ -305,29 +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()
-        # self.root.visit(lambda e : e.resolve_constraints())
 
     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
-
-    def do_on_enter_early(self) -> None:
-        pass
-
-    def do_on_exit_early(self) -> None:
-        pass