batframework 1.0.7__py3-none-any.whl → 1.0.8a1__py3-none-any.whl

batFramework/manager.py

@@ -6,52 +6,66 @@ import random
 class Manager(bf.SceneManager):
     def __init__(self, *initial_scene_list) -> None:
         # random.seed("random")
-        self._screen: pygame.Surface|None = bf.const.SCREEN
+        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()
+        pygame.mouse.set_cursor(bf.const.DEFAULT_CURSOR)
         self.do_pre_init()
-        super().__init__(*initial_scene_list)
+        self.init_scenes(*initial_scene_list)
         self.set_sharedVar("clock", self._clock)
         self.do_init()
 
     @staticmethod
-    def set_icon(path: str)->None:
+    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)->float:
+    def print_status(self):
+        super().print_status()
+        print("TIMERS : ")
+        for r in self._timeManager.get_active_registers():
+            # print(r["timers"])
+            print("\n".join(str(t) for t in r))
+        print("-" * 40)
+
+    def get_fps(self) -> float:
         return self._clock.get_fps()
 
-    def do_init(self)->None:
+    def do_init(self) -> None:
         pass
 
-    def do_pre_init(self)->None:
+    def do_pre_init(self) -> None:
         pass
+
     def stop(self) -> None:
         self._running = False
 
-    def run(self)->None:
+    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 = self._clock.tick(0 if  bf.const.VSYNC else bf.const.FPS) / 1000
+            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._cutsceneManager.update(dt)
             self._timeManager.update(dt)
+            self._cutsceneManager.update(dt)
             self.update(dt)
             # render
-            self._screen.fill((0,0,0))
+            self._screen.fill((0, 0, 0))
             self.draw(self._screen)
             pygame.display.flip()
         pygame.quit()

batFramework/object.py

@@ -0,0 +1,115 @@
+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:
+    __instance_count = 0
+
+    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.__instance_count
+        Object.__instance_count += 1
+
+    @staticmethod
+    def new_uid() -> int:
+        i = Object.__instance_count
+        Object.__instance_count += 1
+        return i
+
+    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:
+        self.uid = uid
+        return self
+
+    def get_uid(self) -> int:
+        return self.uid
+
+    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/{particles.py → particle.py}

@@ -8,6 +8,9 @@ class Particle:
         self.dead = False
         self.surface = None
 
+    def update(self, dt):
+        pass
+
     def kill(self):
         self.dead = True
 
@@ -18,16 +21,7 @@ class Particle:
 class TimedParticle(Particle):
     def __init__(self, duration):
         super().__init__()
-        self.start_time = pygame.time.get_ticks()
-        self.duration = duration
-        self.progression = 0
-
-    def update(self, dt):
-        if self.dead:
-            return
-        elapsed_time = pygame.time.get_ticks() - self.start_time
-        self.progression = elapsed_time / self.duration
-        self.dead = elapsed_time >= self.duration
+        self.timer = bf.Timer(duration, end_callback=self.kill).start()
 
 
 class BasicParticle(TimedParticle):
@@ -35,16 +29,22 @@ class BasicParticle(TimedParticle):
         self,
         start_pos: tuple[float, float],
         start_vel: tuple[float, float],
-        duration=1000,
+        duration=1,
         color=None,
-        size=(4, 4),
+        size: tuple[int, int] = (4, 4),
+        *args,
+        **kwargs,
     ):
-        super().__init__()
-        self.rect = pygame.FRect(*start_pos, 0, 0)
+        super().__init__(duration)
+        self.rect = pygame.FRect(*start_pos, *size)
         self.surface = pygame.Surface(size).convert()
+        self.velocity = Vector2(start_vel)
         if color:
             self.surface.fill(color)
-        self.z_depth = 1
+        self.start()
+
+    def start(self):
+        pass
 
     def update(self, dt):
         super().update(dt)
@@ -52,19 +52,34 @@ class BasicParticle(TimedParticle):
         self.update_surface()
 
     def update_surface(self):
-        self.surface.set_alpha(255 - int(self.progression * 255))
+        self.surface.set_alpha(255 - int(self.timer.get_progression() * 255))
+
+
+class DirectionalParticle(BasicParticle):
+    def start(self):
+        self.surface = self.surface.convert_alpha()
+        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 ParticleManager(bf.Entity):
+class ParticleGenerator(bf.Entity):
     def __init__(self) -> None:
-        super().__init__(size=bf.const.RESOLUTION)
+        super().__init__((0, 0))
         self.particles: list[Particle] = []
 
-    def get_bounding_box(self):
+    def get_debug_outlines(self):
         for particle in self.particles:
-            yield particle.rect
+            yield (
+                particle.rect.move(particle.rect.w // 2, particle.rect.h // 2),
+                "blue",
+            )
+        yield (self.rect, "cyan")
 
-    def add_particle(self, particle=Particle):
+    def add_particle(self, particle):
         self.particles.append(particle)
 
     def clear(self):
@@ -80,19 +95,7 @@ class ParticleManager(bf.Entity):
             self.particles.remove(p)
 
     def draw(self, camera) -> bool:
-        for p in self.particles:
-            p.update_surface()
         camera.surface.fblits(
-            [
-                (
-                    p.surface,
-                    tuple(
-                        round(i * self.z_depth)
-                        for i in camera.transpose(self.rect).topleft
-                    ),
-                )
-                for p in self.particles
-                if p.surface
-            ]
+            [(p.surface, camera.world_to_screen(p.rect).center) for p in self.particles]
         )
         return len(self.particles)

batFramework/renderGroup.py

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

@@ -4,6 +4,7 @@ import pygame
 import sys
 import json
 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
@@ -20,41 +21,52 @@ class ResourceManager(metaclass=Singleton):
         self.sound_cache = {}
         self.RESOURCE_PATH = "."
 
-    def load_dir(self,path)->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] == "."]
 
-            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')):
+                if file.lower().endswith((".png", ".jpg", ".jpeg", ".gif")):
                     self.load_image(file_path)
-                    
-                elif file.lower().endswith(('.mp3', '.wav')):
-                    #AudioManager.load_sound(file_path)
-                    pass
-    def set_resource_path(self,path: str):
+                    # print(f"Loaded image : '{file_path}'")
+
+                elif file.lower().endswith((".mp3", ".wav")):
+                    bf.AudioManager().load_sound(file.lower().split(".")[0], file_path)
+                    # print(f"Loaded sound : '{file_path}'")
+
+                elif file.lower().endswith((".ttf", ".otf")):
+                    bf.FontManager().load_font(file_path, file.lower().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):
-        return os.path.join(self.RESOURCE_PATH, path)
-        
-    def load_image(self,path)->None:
+    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
+        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()
-        print(f"Loaded image : '{path}'")
-        
-    def get_image(self,path,convert_alpha:bool=False):   
+
+    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:
+        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)
@@ -63,7 +75,7 @@ class ResourceManager(metaclass=Singleton):
             print(f"File '{path}' not found")
             return None
 
-    def save_json_to_file(self,path: str, data) -> bool:
+    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)