batframework 1.0.10__py3-none-any.whl → 2.0.0__py3-none-any.whl

batFramework/manager.py

@@ -1,50 +1,131 @@
-import batFramework as bf
-import pygame
-import random
-
-class Manager(bf.SceneManager):
-    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):
-        surf = pygame.image.load(bf.utils.get_path(path)).convert_alpha()
-        pygame.display.set_icon(surf)
-
-    def get_fps(self):
-        return self._clock.get_fps()
-
-    def do_init(self):
-        pass
-
-    def stop(self)->None:
-        self._running = False
-
-    def run(self):
-        self._running = True
-        dt: float = 0
-        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)
-            pygame.display.flip()
-        pygame.quit()
+import batFramework as bf
+from batFramework import const
+import pygame
+import asyncio
+
+
+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)
+        self.do_init()
+
+    @staticmethod
+    def set_icon(path: str) -> None:
+        surf = pygame.image.load(bf.ResourceManager().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:
+        return self.clock.get_fps()
+
+    def do_init(self) -> None:
+        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 run(self) -> None:
+        if len(self.scenes) == 0:
+            raise Exception("Manager can't start without scenes")
+        if self.running:
+            raise Exception("Error : Already running")
+        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) # fix for dt being too high when window not focused for a long time
+        pygame.quit()

batFramework/particle.py

@@ -0,0 +1,118 @@
+import batFramework as bf
+import pygame
+from pygame.math import Vector2
+
+
+class Particle:
+    def __init__(self, *args, **kwargs):
+        self.dead = False
+        self.surface = None
+        self.generator = None
+
+    def do_when_added(self):
+        pass
+
+    def update(self, dt):
+        pass
+
+    def kill(self):
+        self.dead = True
+
+    def update_surface(self):
+        pass
+
+
+class TimedParticle(Particle):
+    def __init__(self, duration):
+        super().__init__()
+        self.duration = duration
+
+    def do_when_added(self):
+        if self.generator and self.generator.parent_scene:
+            self.timer = bf.SceneTimer(
+                self.duration, end_callback=self.kill,
+                scene_name=self.generator.parent_scene.name).start()        
+        else:
+            self.timer = bf.Timer(self.duration, end_callback=self.kill).start()
+
+
+class BasicParticle(TimedParticle):
+    def __init__(
+        self,
+        start_pos: tuple[float, float],
+        start_vel: tuple[float, float],
+        duration=1,
+        color=None,
+        size: tuple[int, int] = (4, 4),
+        *args,
+        **kwargs,
+    ):
+        super().__init__(duration)
+        self.rect = pygame.FRect(0,0, *size)
+        self.rect.center = start_pos
+        self.surface = pygame.Surface(size)
+        self.velocity = Vector2(start_vel)
+        if color:
+            self.surface.fill(color)
+        self.start()
+
+    def start(self):
+        pass
+
+    def update(self, dt):
+        super().update(dt)
+        self.rect.center += self.velocity * dt
+        self.update_surface()
+
+    def update_surface(self):
+        self.surface.set_alpha(255 - int(self.timer.get_progression() * 255))
+
+
+class DirectionalParticle(BasicParticle):
+    def start(self):
+        self.original_surface = self.surface.copy()
+
+    def update_surface(self):
+        angle = self.velocity.angle_to(Vector2(1, 0))
+        self.surface = pygame.transform.rotate(self.original_surface, angle)
+        super().update_surface()
+
+
+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
+        for particle in self.particles:
+            yield (
+                particle.rect.move(particle.rect.w // 2, particle.rect.h // 2),
+                "blue",
+            )
+        yield (self.rect, "cyan")
+
+    def add_particle(self, particle:Particle):
+        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:
+            particle.update(dt)
+            if particle.dead:
+                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(
+            [(p.surface, camera.world_to_screen(p.rect)) for p in self.particles]
+        )

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

@@ -0,0 +1,34 @@
+import batFramework as bf
+import pygame
+from typing import Callable, Iterator
+
+
+class RenderGroup(bf.Drawable):
+    def __init__(
+        self, entity_iterator: Callable[[], Iterator[bf.Drawable]], blit_flags: int = 0
+    ) -> None:
+        super().__init__()
+        self.entity_iterator = entity_iterator
+        self.blit_flags = blit_flags
+        self.set_debug_color("white")
+
+    def draw(self, camera: bf.Camera) -> None:
+        if not self.visible:
+            return
+
+        fblits_data = []
+        for e in self.entity_iterator():
+            if not getattr(e, "drawn_by_group", False):
+                # Set flag to skip their individual draw call
+                e.drawn_by_group = True
+
+            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))
+                )
+
+        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

@@ -0,0 +1,130 @@
+import batFramework as bf
+import os
+import pygame
+import sys
+import json
+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
+    # extends the sys module by a flag frozen=True and sets the app
+    # path into variable _MEIPASS'.
+    application_path = sys._MEIPASS
+else:
+    application_path = os.getcwd()
+
+
+class ResourceManager(metaclass=Singleton):
+    def __init__(self):
+        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_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)
+                elif file.lower().endswith((".mp3", ".wav", ".ogg")):
+                    bf.AudioManager().load_sound(file.split(".")[0], file_path)
+                elif file.lower().endswith((".ttf", ".otf")):
+                    bf.FontManager().load_font(file_path, file.split(".")[0])
+
+                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)
+        print(f"Resource path : '{self.RESOURCE_PATH}'")
+
+    def get_path(self, path: str) -> str:
+        # Normalize path separators
+        normalized_path = path.replace("/", os.sep).replace("\\", os.sep)
+        return os.path.join(self.RESOURCE_PATH, normalized_path)
+
+    def load_image(self, path) -> None:
+        key = self.get_path(path)
+        if key in self.convert_image_cache:
+            return
+        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 (
+            self.convert_alpha_image_cache.get(key, None)
+            if convert_alpha
+            else self.convert_image_cache.get(key, None)
+        )
+
+    def load_json_from_file(self, path: str) -> dict | None:
+        try:
+            with open(self.get_path(path), "r") as file:
+                data = json.load(file)
+            return data
+        except FileNotFoundError:
+            print(f"File '{path}' not found")
+            return None
+
+    def save_json_to_file(self, path: str, data) -> bool:
+        try:
+            with open(self.get_path(path), "w") as file:
+                json.dump(data, file, indent=2)
+            return True
+        except FileNotFoundError:
+            return False
+
+
+    def set_sharedVar(self, name, value) -> bool:
+        """
+        Set a shared variable of any type. This will be accessible (read/write) from any scene
+        """
+        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
+        """
+        return self.shared_variables.get(name, error_value)