batframework 1.0.9a11__py3-none-any.whl → 1.0.9a12__py3-none-any.whl

batFramework/manager.py

@@ -1,134 +1,131 @@
-import batFramework as bf
-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")
-            return
-        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
-        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

@@ -1,118 +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]
-        )
+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

@@ -1,79 +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
+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