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

batFramework/manager.py

@@ -2,82 +2,49 @@ import batFramework as bf
 import pygame
 import random
 
-
 class Manager(bf.SceneManager):
     def __init__(self, *initial_scene_list) -> None:
-        # random.seed("random")
-        super().__init__()
-        self._screen: pygame.Surface | None = bf.const.SCREEN
-        self._timeManager = bf.TimeManager()
-        self._cutsceneManager = bf.CutsceneManager()
-        self._cutsceneManager.set_manager(self)
+        random.seed("random")
+        self._screen: pygame.Surface = bf.const.SCREEN
+        self._timeManager = bf.Time()
+        self._cutsceneManager = bf.CutsceneManager(self)
         self._clock: pygame.Clock = pygame.Clock()
-        pygame.mouse.set_cursor(bf.const.DEFAULT_CURSOR)
-        self.do_pre_init()
-        self.init_scenes(*initial_scene_list)
+        super().__init__(*initial_scene_list)
         self.set_sharedVar("clock", self._clock)
         self.do_init()
 
     @staticmethod
-    def set_icon(path: str) -> None:
-        surf = pygame.image.load(bf.ResourceManager().get_path(path)).convert_alpha()
+    def set_icon(path: str):
+        surf = pygame.image.load(bf.utils.get_path(path)).convert_alpha()
         pygame.display.set_icon(surf)
 
-    def print_status(self):
-        """
-        Print detailed information about the current state of the scenes, shared variables,
-        and additional timers managed by the subclass.
-        """
-        # Call the parent class's print_status method to include its information
-        super().print_status()
-        
-        # Add the timers information in a cohesive manner
-        print("\n" + "=" * 50)
-        print(" TIMERS".center(50))
-        print("=" * 50)
-        
-        # Print the timers information
-        print(self._timeManager)
-        
-        # End with a visual separator
-        print("=" * 50 + "\n")
-
-
-    def get_fps(self) -> float:
+    def get_fps(self):
         return self._clock.get_fps()
 
-    def do_init(self) -> None:
-        pass
-
-    def do_pre_init(self) -> None:
+    def do_init(self):
         pass
 
-    def stop(self) -> None:
+    def stop(self)->None:
         self._running = False
 
-    def run(self) -> None:
+    def run(self):
         self._running = True
         dt: float = 0
         while self._running:
             for event in pygame.event.get():
-                event.consumed = False
+                if event.type == pygame.QUIT:
+                    self._running = False
+                    break
+                if event.type == pygame.VIDEORESIZE:
+                    bf.const.set_resolution((event.w,event.h))
                 self.process_event(event)
-                if not event.consumed:
-                    if event.type == pygame.QUIT:
-                        self._running = False
-                        break
-                    if event.type == pygame.VIDEORESIZE and not (
-                        bf.const.FLAGS & pygame.SCALED
-                    ):
-                        bf.const.set_resolution((event.w, event.h))
             # update
-            dt = self._clock.tick(bf.const.FPS) / 1000
-            # dt = min(dt, 0.02) dirty fix for dt being too high when window not focused for a long time
-            self._timeManager.update(dt)
+            dt = self._clock.tick(bf.const.FPS if  not bf.const.VSYNC else 0) / 1000
+            dt = min(dt, 0.02)
             self._cutsceneManager.update(dt)
+            self._timeManager.update()
             self.update(dt)
             # render
-            self._screen.fill((0, 0, 0))
             self.draw(self._screen)
             pygame.display.flip()
         pygame.quit()

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,333 +1,203 @@
 from __future__ import annotations
 import re
-from collections import OrderedDict
-import itertools
-
-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
-        bf.TimeManager().add_register(self.name,False)
+    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: 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)
-        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.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.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
-
-    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)
+        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):
-        """Get entities by their tags."""
-        res = [
+        return [
             entity
-            for entity in itertools.chain(
-                self.world_entities.keys(), self.hud_entities.keys()
-            )
-            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, itertools.chain(self.world_entities.keys(), self.hud_entities.keys())
+        return next(
+            (
+                entity
+                for entity in self._world_entities + self._hud_entities
+                if entity.uid == uid
+            ),
+            None,
         )
-        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
+    # 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:
+        if self.get_sharedVar("in_transition"):
             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:
+        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"""
-        if self.should_sort:
-            self._sort_entities_internal()
-
-        for entity in itertools.chain(
-            self.hud_entities.keys(), self.world_entities.keys()
-        ):
+        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()
-
-
-        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):
+        # 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)
+            if not isinstance(color,pygame.Color): color = pygame.Color(color)
 
-        [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
+            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.keys())
-        # Draw all HUD entities
-        self._draw_camera(self.hud_camera, self.hud_entities.keys())
+
+        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)
@@ -335,12 +205,7 @@ class Scene:
         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 = 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]
+        self.blit_calls = total_blit_calls
 
     def do_early_draw(self, surface: pygame.Surface):
         pass
@@ -354,31 +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()
-        bf.TimeManager().activate_register(self.name)
-        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()
-        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