batframework 1.0.9a7__py3-none-any.whl → 1.0.9a9__py3-none-any.whl

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

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()