batframework 1.0.9a11__py3-none-any.whl → 1.1.0__py3-none-any.whl

batFramework/manager.py

@@ -1,134 +1,50 @@
 import batFramework as bf
 import pygame
-import asyncio
+import random
 
 class Manager(bf.SceneManager):
-    def __init__(self, *initial_scenes) -> None:
-        super().__init__()
-        self.debug_mode: bf.enums.debugMode = bf.debugMode.HIDDEN
-        self.screen: pygame.Surface | None = bf.const.SCREEN
-        self.timeManager = bf.TimeManager()
-        self.cutsceneManager = bf.CutsceneManager()
-        self.cutsceneManager.set_manager(self)
-        self.clock: pygame.Clock = pygame.Clock()
-        self.is_async_running : bool = False
-        self.running = False
-        pygame.mouse.set_cursor(bf.const.DEFAULT_CURSOR)
-        bf.ResourceManager().set_sharedVar("clock", self.clock)
-        bf.ResourceManager().set_sharedVar("debug_mode", self.debug_mode)
-        
-        self.do_pre_init()
-        if initial_scenes:
-            self.init_scenes(*initial_scenes)
+    def __init__(self, *initial_scene_list) -> None:
+        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()
+        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):
+        return self._clock.get_fps()
 
-
-    def get_fps(self) -> float:
-        return self.clock.get_fps()
-
-    def do_init(self) -> None:
+    def do_init(self):
         pass
 
-    def do_pre_init(self) -> None:
-        pass
-
-    def stop(self) -> None:
-        self.running = False
-
-    def process_event(self, event: pygame.Event):
-        event.consumed = False
-        keys = pygame.key.get_pressed()
-        if (
-            bf.const.ALLOW_DEBUG and
-            keys[pygame.K_LCTRL]
-            and keys[pygame.K_LSHIFT]
-            and event.type == pygame.KEYDOWN
-        ):
-            if event.key == pygame.K_d:
-                self.cycle_debug_mode()
-                return
-            if event.key == pygame.K_p:
-                self.print_status()
-                return
-        self.cutsceneManager.process_event(event)
-        if event.type == pygame.VIDEORESIZE and not (bf.const.FLAGS & pygame.SCALED):
-            bf.const.set_resolution((event.w, event.h))
-
-        if event.consumed: return
-        
-        super().process_event(event)
-        if not event.consumed:
-            if event.type == pygame.QUIT:
-                self.running = False
-
-    def update(self, dt: float) -> None:
-        self.timeManager.update(dt)
-        self.cutsceneManager.update(dt)
-        super().update(dt)
-
-
-    async def run_async(self):
-        if len(self.scenes) == 0:
-            raise Exception("Manager can't start without scenes")
-        if self.running:
-            raise Exception("Error : Already running")
-        self.is_async_running = True
-        self.running = True
-        dt: float = 0
-        while self.running:
-            for event in pygame.event.get():
-                self.process_event(event)
-            # update
-            self.update(dt)
-            # render
-            self.draw(self.screen)
-            pygame.display.flip()
-            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
-            await asyncio.sleep(0)
-        pygame.quit()
-
+    def stop(self)->None:
+        self._running = False
 
-    def run(self) -> None:
-        if len(self.scenes) == 0:
-            raise Exception("Manager can't start without scenes")
-        if self.running:
-            raise Exception("Error : Already running")
-            return
-        self.running = True
+    def run(self):
+        self._running = True
         dt: float = 0
-        while self.running:
+        while self._running:
             for event in pygame.event.get():
+                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)
             # update
+            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.draw(self.screen)
+            self.draw(self._screen)
             pygame.display.flip()
-            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
         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,31 +1,226 @@
-from .baseScene import BaseScene
+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(BaseScene):
-    def __init__(self,name: str) -> None:
+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):
         """
-        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.
+        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.
         """
-        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 = []
+        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.root.clear_hovered()
-        self.root.build()
-        super().on_enter()
+        self.set_active(True)
+        self.set_visible(True)
 
     def on_exit(self):
-        self.root.clear_hovered()
-        super().on_exit()
+        self.set_active(False)
+        self.set_visible(False)
+        self.actions.hard_reset()