batframework 1.0.8a9__py3-none-any.whl → 1.0.8a10__py3-none-any.whl

batFramework/manager.py

@@ -2,49 +2,82 @@ 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)
+        # random.seed("random")
+        super().__init__()
+        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()
-        super().__init__(*initial_scene_list)
+        pygame.mouse.set_cursor(bf.const.DEFAULT_CURSOR)
+        self.do_pre_init()
+        self.init_scenes(*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()
+    def set_icon(path: str) -> None:
+        surf = pygame.image.load(bf.ResourceManager().get_path(path)).convert_alpha()
         pygame.display.set_icon(surf)
 
-    def get_fps(self):
+    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):
+    def do_init(self) -> None:
+        pass
+
+    def do_pre_init(self) -> None:
         pass
 
-    def stop(self)->None:
+    def stop(self) -> None:
         self._running = False
 
-    def run(self):
+    def run(self) -> None:
         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))
+                event.consumed = False
                 self.process_event(event)
+                if not event.consumed:
+                    if event.type == pygame.QUIT:
+                        self._running = False
+                        break
+                    if event.type == pygame.VIDEORESIZE and not (
+                        bf.const.FLAGS & pygame.SCALED
+                    ):
+                        bf.const.set_resolution((event.w, event.h))
             # update
-            dt = self._clock.tick(bf.const.FPS if  not bf.const.VSYNC else 0) / 1000
-            dt = min(dt, 0.02)
+            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
+            self._timeManager.update(dt)
             self._cutsceneManager.update(dt)
-            self._timeManager.update()
             self.update(dt)
             # render
+            self._screen.fill((0, 0, 0))
             self.draw(self._screen)
             pygame.display.flip()
         pygame.quit()

batFramework/object.py

@@ -0,0 +1,123 @@
+from typing import Any, Self
+import pygame
+import batFramework as bf
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .camera import Camera
+
+
+class Object:
+    __count = 0
+    __available_uid = set()
+    __used_uid = set()
+
+    def __init__(self) -> None:
+        self.rect = pygame.FRect(0, 0, 0, 0)
+        self.tags: list[str] = []
+        self.parent_scene: bf.Scene | None = None
+        self.debug_color: tuple | str = "red"
+        self.render_order: int = 0
+        self.uid: int = Object.__count
+        Object.__used_uid.add(self.uid)
+
+        if Object.__available_uid:
+            self.name = Object.__available_uid.pop()
+        else:
+            self.name = Object.__count
+            Object.__count += 1
+
+    def __del__(self):
+        Object.__available_uid.add(self.uid)
+
+    def set_position(self, x, y) -> Self:
+        self.rect.topleft = x, y
+        return self
+
+    def set_center(self, x, y) -> Self:
+        self.rect.center = x, y
+        return self
+
+    def get_debug_outlines(self):
+        yield (self.rect, self.debug_color)
+
+    def set_debug_color(self, color) -> Self:
+        self.debug_color = color
+        return self
+
+    def set_parent_scene(self, scene) -> Self:
+        if scene == self.parent_scene:
+            return self
+        if self.parent_scene is not None:
+            self.do_when_removed()
+        self.parent_scene = scene
+        if scene is not None:
+            self.do_when_added()
+        return self
+
+    def do_when_added(self):
+        pass
+
+    def do_when_removed(self):
+        pass
+
+    def set_uid(self, uid: int) -> Self:
+        if uid in Object.__used_uid:
+            print(f"set_uid error : UID '{uid}' is already in use")
+            return self
+        self.uid = uid
+        Object.__used_uid.add(uid)
+        return self
+
+    def add_tags(self, *tags) -> Self:
+        for tag in tags:
+            if tag not in self.tags:
+                self.tags.append(tag)
+        self.tags.sort()
+        return self
+
+    def remove_tags(self, *tags):
+        self.tags = [tag for tag in self.tags if tag not in tags]
+
+    def has_tags(self, *tags) -> bool:
+        return all(tag in self.tags for tag in tags)
+
+    def get_tags(self) -> list[str]:
+        return self.tags
+
+    def process_event(self, event: pygame.Event) -> bool:
+        """
+        Returns bool : True if the method is blocking (no propagation to next object of the scene)
+        """
+        if event.consumed:
+            return
+        self.do_process_actions(event)
+        self.do_handle_event(event)
+
+    def do_process_actions(self, event: pygame.Event) -> None:
+        """
+        Process entity actions you may have set
+        """
+
+    def do_reset_actions(self) -> None:
+        """
+        Reset entity actions you may have set
+        """
+
+    def do_handle_event(self, event: pygame.Event):
+        """
+        Handle specific events with no action support
+        """
+        return False
+
+    def update(self, dt: float) -> None:
+        """
+        Update method to be overriden by subclasses of object (must call do_update and do_reset_actions)
+        """
+        self.do_update(dt)
+        self.do_reset_actions()
+
+    def do_update(self, dt: float) -> None:
+        """
+        Update method to be overriden for specific behavior by the end user
+        """

batFramework/particle.py

@@ -0,0 +1,115 @@
+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.Entity):
+    def __init__(self) -> None:
+        super().__init__((0, 0))
+        self.particles: list[Particle] = []
+
+    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)
+
+    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) -> None:
+        camera.surface.fblits(
+            [(p.surface, camera.world_to_screen(p.rect)) for p in self.particles]
+        )

batFramework/renderGroup.py

@@ -0,0 +1,67 @@
+import batFramework as bf
+import pygame
+from typing import Self, Iterator, Callable
+
+"""
++ same render order
++ fblits
+"""
+
+
+class RenderGroup(bf.Entity):
+    def __init__(
+        self, entity_iterator: Callable[[], Iterator[bf.Entity]], blit_flags: int = 0
+    ) -> None:
+        super().__init__()
+        self.entity_iterator = entity_iterator
+        self.set_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 update(self, dt: float) -> None:
+        """
+        Update method to be overriden by subclasses of entity
+        """
+        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])
+
+        self.do_update(dt)
+        self.do_reset_actions()
+
+    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)

batFramework/resourceManager.py

@@ -0,0 +1,100 @@
+import batFramework as bf
+import os
+import pygame
+import sys
+import json
+from typing import Any
+from .utils import Singleton
+
+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 = "."
+
+    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] == "."]
+
+            for file in files:
+                file_path = os.path.join(root, file)
+                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")):
+                    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}'")
+
+    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 get_sharedVar(self, name, error_value=None):
+        """
+        Get a shared variable
+        """
+        return self.shared_variables.get(name, error_value)