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

batFramework/manager.py

@@ -3,7 +3,7 @@ import pygame
 import asyncio
 
 class Manager(bf.SceneManager):
-    def __init__(self, *initial_scene_list) -> None:
+    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
@@ -18,8 +18,8 @@ class Manager(bf.SceneManager):
         bf.ResourceManager().set_sharedVar("debug_mode", self.debug_mode)
         
         self.do_pre_init()
-        if initial_scene_list:
-            self.init_scenes(*initial_scene_list)
+        if initial_scenes:
+            self.init_scenes(*initial_scenes)
         self.do_init()
 
     @staticmethod
@@ -75,15 +75,15 @@ class Manager(bf.SceneManager):
                 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
-            elif event.type == pygame.VIDEORESIZE and not (
-                bf.const.FLAGS & pygame.SCALED
-            ):
-                bf.const.set_resolution((event.w, event.h))
 
     def update(self, dt: float) -> None:
         self.timeManager.update(dt)
@@ -96,7 +96,6 @@ class Manager(bf.SceneManager):
             raise Exception("Manager can't start without scenes")
         if self.running:
             raise Exception("Error : Already running")
-            return
         self.is_async_running = True
         self.running = True
         dt: float = 0

batFramework/particle.py

@@ -82,6 +82,7 @@ class ParticleGenerator(bf.Drawable):
     def __init__(self) -> None:
         super().__init__((0, 0))
         self.particles: list[Particle] = []
+        self.count = 0
 
     def get_debug_outlines(self):
         return
@@ -96,10 +97,11 @@ class ParticleGenerator(bf.Drawable):
         particle.generator = self
         particle.do_when_added()
         self.particles.append(particle)
+        self.count += 1
 
     def clear(self):
         self.particles = []
-
+        self.count = 0
     def update(self, dt: float):
         particles_to_remove = []
         for particle in self.particles:
@@ -108,6 +110,7 @@ class ParticleGenerator(bf.Drawable):
                 particles_to_remove.append(particle)
         for p in particles_to_remove:
             self.particles.remove(p)
+            self.count -= 1
 
     def draw(self, camera) -> None:
         camera.surface.fblits(

batFramework/propertyEaser.py

@@ -0,0 +1,79 @@
+from .easingController import EasingController
+import pygame
+from typing import Callable, Any, Self
+import batFramework as bf
+
+class PropertyEaser(EasingController):
+    class EasedProperty:
+        def __init__(self, getter: Callable[[], Any], setter: Callable[[Any], None], end_value: Any, start_value: Any = None):
+            self.getter = getter
+            self.setter = setter
+            self.start_value = start_value if start_value is not None else getter()
+            self.end_value = end_value
+
+        def interpolate(self, t: float):
+            a, b = self.start_value, self.end_value
+            if isinstance(a, (int, float)):
+                return a + (b - a) * t
+            elif isinstance(a, pygame.Vector2):
+                return a.lerp(b, t)
+            elif isinstance(a, pygame.Color):
+                return pygame.Color(
+                    round(a.r + (b.r - a.r) * t),
+                    round(a.g + (b.g - a.g) * t),
+                    round(a.b + (b.b - a.b) * t),
+                    round(a.a + (b.a - a.a) * t),
+                )
+            else:
+                raise TypeError(f"Unsupported type for interpolation: {type(a)}")
+
+        def apply(self, t: float):
+            self.setter(self.interpolate(t))
+
+    def __init__(
+        self,
+        duration: float = 1,
+        easing: bf.easing = bf.easing.LINEAR,
+        loop: int = 0,
+        register: str = "global",
+        end_callback: Callable[[], Any] = None,
+    ):
+        self.properties: list[PropertyEaser.EasedProperty] = []
+
+        def update_all(progress):
+            for prop in self.properties:
+                prop.apply(progress)
+
+        super().__init__(duration, easing, update_all, end_callback, loop, register)
+
+    def __str__(self):
+        return f"(PROP){super().__str__()}"
+
+    def add_attr(
+        self,
+        obj: Any,
+        attr: str,
+        end_value: Any,
+        start_value: Any = None,
+    )->Self:
+        self.properties.append(
+            PropertyEaser.EasedProperty(
+                getter=lambda o=obj, a=attr: getattr(o, a),
+                setter=lambda v, o=obj, a=attr: setattr(o, a, v),
+                end_value=end_value,
+                start_value=start_value,
+            )
+        )
+        return self
+
+    def add_custom(
+        self,
+        getter: Callable[[], Any],
+        setter: Callable[[Any], None],
+        end_value: Any,
+        start_value: Any = None,
+    )->Self:
+        self.properties.append(
+            PropertyEaser.EasedProperty(getter, setter, end_value, start_value)
+        )
+        return self

batFramework/renderGroup.py

@@ -1,11 +1,6 @@
 import batFramework as bf
 import pygame
-from typing import Self, Iterator, Callable
-
-"""
-+ same render order
-+ fblits
-"""
+from typing import Callable, Iterator
 
 
 class RenderGroup(bf.Drawable):
@@ -14,54 +9,26 @@ class RenderGroup(bf.Drawable):
     ) -> None:
         super().__init__()
         self.entity_iterator = entity_iterator
-        # self.set_blit_flags(blit_flags)
+        self.blit_flags = blit_flags
         self.set_debug_color("white")
 
-    def get_debug_outlines(self):
-        # yield (self.rect, self.debug_color)
-        for e in self.entity_iterator():
-            yield from e.get_debug_outlines()
-
-    def set_parent_scene(self, scene) -> Self:
-        self.parent_scene = scene
-        for e in self.entity_iterator():
-            e.set_parent_scene(scene)
-        return self
-
-    def process_event(self, event: pygame.Event) -> bool:
-        """
-        Returns bool : True if the method is blocking (no propagation to next children of the scene)
-        """
-        self.do_process_actions(event)
-        res = self.do_handle_event(event)
-        if res:
-            return res
-        for e in self.entity_iterator():
-            if e.process_event(event):
-                return True
-        return False
+    def draw(self, camera: bf.Camera) -> None:
+        if not self.visible:
+            return
 
-    def update(self, dt: float) -> None:
-        """
-        Update method to be overriden by subclasses of entity
-        """
+        fblits_data = []
         for e in self.entity_iterator():
-            e.update(dt)
-        # gen = self.entity_iterator()
-        # self.rect = next(gen).rect.unionall([e.rect for e in gen])
+            if not getattr(e, "drawn_by_group", False):
+                # Set flag to skip their individual draw call
+                e.drawn_by_group = True
 
-        self.do_update(dt)
-        self.do_reset_actions()
+            if e.visible and camera.rect.colliderect(e.rect):
+                fblits_data.append(
+                    (e.surface, (e.rect.x - camera.rect.x, e.rect.y - camera.rect.y))
+                )
 
-    def draw(self, camera: bf.Camera) -> None:
-        """
-        Draw the entity onto the camera with coordinate transposing
-        """
-        if not self.visible:
-            return
-        fblits_data = (
-            (e.surface, (e.rect.x - camera.rect.x, e.rect.y - camera.rect.y))
-            for e in self.entity_iterator()
-            if camera.rect.colliderect(e.rect)
-        )
         camera.surface.fblits(fblits_data, self.blit_flags)
+
+    def get_debug_outlines(self):
+        for e in self.entity_iterator():
+            yield from e.get_debug_outlines()

batFramework/resourceManager.py

@@ -3,8 +3,10 @@ import os
 import pygame
 import sys
 import json
-from typing import Any
+from typing import Any, Callable
 from .utils import Singleton
+import asyncio
+
 
 if getattr(sys, "frozen", False):
     # If the application is run as a bundle, the PyInstaller bootloader
@@ -17,32 +19,50 @@ else:
 
 class ResourceManager(metaclass=Singleton):
     def __init__(self):
-        self.shared_variables: dict[str,Any] = {}
+        self.shared_variables: dict[str, Any] = {}
         self.convert_image_cache = {}
         self.convert_alpha_image_cache = {}
         self.sound_cache = {}
         self.RESOURCE_PATH = "."
+        self.loading_thread = None
 
-    def load_dir(self, path) -> None:
-        for root, dirs, files in os.walk(path):
-            files = [f for f in files if not f[0] == "."]
-            dirs[:] = [d for d in dirs if not d[0] == "."]
+    def load_resources(self, path: str, progress_callback: Callable[[float], Any] = None):
+        """
+        loads resources from a directory.
+        Progress is reported through the callback.
+        Supposed to be asynchronous but don't use it as such yet
+        """
+        self.progress_callback = progress_callback
+
+        total_files = sum(
+            len(files) for _, _, files in os.walk(path) if not any(f.startswith(".") for f in files)
+        )
+
+        loaded_files = 0
 
+        for root, dirs, files in os.walk(path):
+            files = [f for f in files if not f.startswith(".")]
+            dirs[:] = [d for d in dirs if not (d.startswith(".") or d.startswith("__"))]
             for file in files:
                 file_path = os.path.join(root, file)
+
+                # Simulate resource loading
+                # await asyncio.sleep(0)  # Yield control to the event loop
+
                 if file.lower().endswith((".png", ".jpg", ".jpeg", ".gif")):
                     self.load_image(file_path)
-                    # print(f"Loaded image : '{file_path}'")
-
-                elif file.lower().endswith((".mp3", ".wav")):
+                elif file.lower().endswith((".mp3", ".wav", ".ogg")):
                     bf.AudioManager().load_sound(file.split(".")[0], file_path)
-                    # print(f"Loaded sound : '{file_path}'")
-
                 elif file.lower().endswith((".ttf", ".otf")):
                     bf.FontManager().load_font(file_path, file.split(".")[0])
-                    # print(f"Loaded font : '{file_path}'")
 
-        print(f"Loaded resources in directory : '{path}'")
+                loaded_files += 1
+                # Report progress
+                # if self.progress_callback:
+                    # self.progress_callback(loaded_files / total_files)
+
+        print(f"Loaded resources in directory: '{path}'")
+
 
     def set_resource_path(self, path: str):
         self.RESOURCE_PATH = os.path.join(application_path, path)
@@ -60,6 +80,7 @@ class ResourceManager(metaclass=Singleton):
         self.convert_image_cache[key] = pygame.image.load(path).convert()
         self.convert_alpha_image_cache[key] = pygame.image.load(path).convert_alpha()
 
+
     def get_image(self, path, convert_alpha: bool = False) -> pygame.Surface | None:
         key = self.get_path(path)
         return (
@@ -93,6 +114,15 @@ class ResourceManager(metaclass=Singleton):
         self.shared_variables[name] = value
         return True
 
+    def set_sharedVars(self, variables: dict) -> bool:
+        """
+        Set multiple shared variables at once. This will be accessible (read/write) from any scene.
+        """
+        if not isinstance(variables, dict):
+            raise ValueError("Input must be a dictionary")
+        self.shared_variables.update(variables)
+        return True
+
     def get_sharedVar(self, name, error_value=None):
         """
         Get a shared variable