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

batFramework/sceneManager.py

@@ -1,197 +1,200 @@
-import batFramework as bf
-import pygame
-from typing import Self
-
-def swap(lst, index1, index2):
-    lst[index1], lst[index2] = lst[index2], lst[index1]
-
-
-class SceneManager:
-    def __init__(self) -> None:
-        self.scenes: list[bf.BaseScene] = []
-        self.shared_events = {pygame.WINDOWRESIZED}
-        self.current_transition : tuple[str,bf.transition.Transition,int] | None= None
-
-    def init_scenes(self, *initial_scenes:bf.Scene):
-        for index, s in enumerate(initial_scenes):
-            s.set_scene_index(index)
-        for s in reversed(initial_scenes):
-            self.add_scene(s)
-        self.set_scene(initial_scenes[0].get_name())
-        self.update_scene_states()
-
-    def set_shared_event(self, event: pygame.Event) -> None:
-        """
-        Add an event that will be propagated to all active scenes, not just the one on top.
-        """
-        self.shared_events.add(event)
-
-    def print_status(self):
-        """
-        Print detailed information about the current state of the scenes and shared variables.
-        """
-
-        def format_scene_info(scene:bf.Scene):
-            status = 'Active' if scene.active else 'Inactive'
-            visibility = 'Visible' if scene.visible else 'Invisible'
-            return f"{scene.name:<30} | {status:<8} | {visibility:<10} | Index={scene.scene_index}"
-
-        def format_shared_variable(name, value):
-            return f"[{name}] = {value}"
-
-        print("\n" + "=" * 50)
-        print(" SCENE STATUS".center(50))
-        print("=" * 50)
-
-        # Print scene information
-        if self.scenes:
-            header = f"{'Scene Name':<30} | {'Status':<8} | {'Visibility':<10} | {'Index':<7}"
-            print(header)
-            print("-" * 50)
-            print("\n".join(format_scene_info(s) for s in self.scenes))
-        else:
-            print("No scenes available.")
-
-        # Print debugging mode status
-        print("\n" + "=" * 50)
-        print(" DEBUGGING STATUS".center(50))
-        print("=" * 50)
-        print(f"[Debugging Mode] = {bf.ResourceManager().get_sharedVar("debug_mode")}")
-
-        # Print shared variables
-        print("\n" + "=" * 50)
-        print(" SHARED VARIABLES".center(50))
-        print("=" * 50)
-
-        if bf.ResourceManager().shared_variables:
-            for name, value in bf.ResourceManager().shared_variables.items():
-                print(format_shared_variable(name, value))
-        else:
-            print("No shared variables available.")
-
-        print("=" * 50 + "\n")
-
-    def get_current_scene_name(self) -> str:
-        """get the name of the current scene"""
-        return self.scenes[0].get_name()
-
-    def get_current_scene(self) -> bf.Scene:
-        return self.scenes[0]
-
-    def update_scene_states(self):
-        self.active_scenes = [s for s in reversed(self.scenes) if s.active]
-        self.visible_scenes = [s for s in reversed(self.scenes) if s.visible]
-
-    def add_scene(self, scene: bf.Scene):
-        if scene in self.scenes and not self.has_scene(scene.name):
-            return
-        scene.set_manager(self)
-        scene.when_added()
-        self.scenes.insert(0, scene)
-
-    def remove_scene(self, name: str):
-        self.scenes = [s for s in self.scenes if s.name != name]
-
-    def has_scene(self, name:str):
-        return any(name == scene.name for scene in self.scenes)
-
-    def get_scene(self, name:str):
-        if not self.has_scene(name):
-            return None
-        for scene in self.scenes:
-            if scene.name == name:
-                return scene
-
-    def get_scene_at(self, index: int) -> bf.Scene | None:
-        if index < 0 or index >= len(self.scenes):
-            return None
-        return self.scenes[index]
-
-    def transition_to_scene(
-        self,
-        scene_name: str,
-        transition: bf.transition.Transition = None,
-        index: int = 0,
-    ):
-        if transition is None:
-            transition = bf.transition.Fade(0.1)
-        if not (target_scene := self.get_scene(scene_name)):
-            print(f"Scene '{scene_name}' does not exist")
-            return
-        if not (source_scene := self.get_scene_at(index)):
-            print(f"No scene exists at index {index}.")
-            return       
-        
-        source_surface = bf.const.SCREEN.copy()
-        dest_surface = bf.const.SCREEN.copy()
-
-        target_scene.draw(dest_surface) # draw at least once to ensure smooth transition
-        target_scene.set_active(True)
-        target_scene.set_visible(True)
-
-        target_scene.do_on_enter_early() 
-        source_scene.do_on_exit_early()
-
-        self.current_transition :tuple[str,bf.transition.Transition]=(scene_name,transition,index)
-        transition.set_source(source_surface)
-        transition.set_dest(dest_surface)
-        transition.start()
-
-
-
-    def set_scene(self, scene_name, index=0, ignore_early: bool = False):
-        target_scene = self.get_scene(scene_name)
-        if not target_scene:
-            print(f"'{scene_name}' does not exist")
-            return
-        if len(self.scenes) == 0 or index >= len(self.scenes) or index < 0:
-            return
-
-        # switch
-        if not ignore_early:
-            self.scenes[index].do_on_exit_early()
-        self.scenes[index].on_exit()
-        # re-insert scene at index 0
-        self.scenes.remove(target_scene)
-        self.scenes.insert(index, target_scene)
-        _ = [s.set_scene_index(i) for i, s in enumerate(self.scenes)]
-        if not ignore_early:
-            self.scenes[index].do_on_enter_early()
-        target_scene.on_enter()
-
-
-
-    def cycle_debug_mode(self):
-        current_index = bf.ResourceManager().get_sharedVar("debug_mode").value
-        next_index = (current_index + 1) % len(bf.debugMode)
-        bf.ResourceManager().set_sharedVar("debug_mode", bf.debugMode(next_index))
-        return bf.debugMode(next_index)
-
-    def process_event(self, event: pygame.Event):
-
-        if event.type in self.shared_events:
-            [s.process_event(event) for s in self.scenes]
-        else:
-            self.scenes[0].process_event(event)
-
-    def update(self, dt: float) -> None:
-        for scene in self.active_scenes:
-            scene.update(dt)
-        if self.current_transition and self.current_transition[1].is_over:
-            self.set_scene(self.current_transition[0],self.current_transition[2],True)
-            self.current_transition = None
-        self.do_update(dt)
-
-    def do_update(self, dt: float):
-        pass
-
-    def draw(self, surface:pygame.Surface) -> None:
-        for scene in self.visible_scenes:
-            scene.draw(surface)
-        if self.current_transition is not None:
-            self.current_transition[1].set_source(surface)
-            tmp = surface.copy()
-            self.get_scene(self.current_transition[0]).draw(tmp)
-            self.current_transition[1].set_dest(tmp)
-            self.current_transition[1].draw(surface)
-
+import batFramework as bf
+import pygame
+from typing import Self
+
+def swap(lst, index1, index2):
+    lst[index1], lst[index2] = lst[index2], lst[index1]
+
+
+class SceneManager:
+    def __init__(self) -> None:
+        self.scenes: list[bf.BaseScene] = []
+        self.shared_events = {pygame.WINDOWRESIZED}
+        self.current_transition : tuple[str,bf.transition.Transition,int] | None= None
+
+    def init_scenes(self, *initial_scenes:bf.Scene):
+        for index, s in enumerate(initial_scenes):
+            s.set_scene_index(index)
+        for s in reversed(initial_scenes):
+            self.add_scene(s)
+        self.set_scene(initial_scenes[0].get_name())
+        self.update_scene_states()
+
+    def set_shared_event(self, event: pygame.Event) -> None:
+        """
+        Add an event that will be propagated to all active scenes, not just the one on top.
+        """
+        self.shared_events.add(event)
+
+    def print_status(self):
+        """
+        Print detailed information about the current state of the scenes and shared variables.
+        """
+
+        def format_scene_info(scene:bf.Scene):
+            status = 'Active' if scene.active else 'Inactive'
+            visibility = 'Visible' if scene.visible else 'Invisible'
+            return f"{scene.name:<30} | {status:<8} | {visibility:<10} | Index={scene.scene_index}"
+
+        def format_shared_variable(name, value):
+            return f"[{name}] = {value}"
+
+        print("\n" + "=" * 50)
+        print(" SCENE STATUS".center(50))
+        print("=" * 50)
+
+        # Print scene information
+        if self.scenes:
+            header = f"{'Scene Name':<30} | {'Status':<8} | {'Visibility':<10} | {'Index':<7}"
+            print(header)
+            print("-" * 50)
+            print("\n".join(format_scene_info(s) for s in self.scenes))
+        else:
+            print("No scenes available.")
+
+        # Print debugging mode status
+        print("\n" + "=" * 50)
+        print(" DEBUGGING STATUS".center(50))
+        print("=" * 50)
+        print(f"[Debugging Mode] = {bf.ResourceManager().get_sharedVar('debug_mode')}")
+
+        # Print shared variables
+        print("\n" + "=" * 50)
+        print(" SHARED VARIABLES".center(50))
+        print("=" * 50)
+
+        if bf.ResourceManager().shared_variables:
+            for name, value in bf.ResourceManager().shared_variables.items():
+                print(format_shared_variable(name, value))
+        else:
+            print("No shared variables available.")
+
+        print("=" * 50 + "\n")
+
+    def get_current_scene_name(self) -> str:
+        """get the name of the current scene"""
+        return self.scenes[0].get_name()
+
+    def get_current_scene(self) -> bf.Scene:
+        return self.scenes[0]
+
+    def update_scene_states(self):
+        self.active_scenes = [s for s in reversed(self.scenes) if s.active]
+        self.visible_scenes = [s for s in reversed(self.scenes) if s.visible]
+
+    def add_scene(self, scene: bf.Scene):
+        if scene in self.scenes and not self.has_scene(scene.name):
+            return
+        scene.set_manager(self)
+        scene.when_added()
+        self.scenes.insert(0, scene)
+
+    def remove_scene(self, name: str):
+        self.scenes = [s for s in self.scenes if s.name != name]
+
+    def has_scene(self, name:str):
+        return any(name == scene.name for scene in self.scenes)
+
+    def get_scene(self, name:str):
+        if not self.has_scene(name):
+            return None
+        for scene in self.scenes:
+            if scene.name == name:
+                return scene
+
+    def get_scene_at(self, index: int) -> bf.Scene | None:
+        if index < 0 or index >= len(self.scenes):
+            return None
+        return self.scenes[index]
+
+    def transition_to_scene(
+        self,
+        scene_name: str,
+        transition: bf.transition.Transition = None,
+        index: int = 0,
+    ):
+        if transition is None:
+            transition = bf.transition.Fade(0.1)
+        if not (target_scene := self.get_scene(scene_name)):
+            print(f"Scene '{scene_name}' does not exist")
+            return
+        if not (source_scene := self.get_scene_at(index)):
+            print(f"No scene exists at index {index}.")
+            return       
+        
+        source_surface = bf.const.SCREEN.copy()
+        dest_surface = bf.const.SCREEN.copy()
+
+        target_scene.draw(dest_surface) # draw at least once to ensure smooth transition
+        target_scene.set_active(True)
+        target_scene.set_visible(True)
+
+        target_scene.do_on_enter_early() 
+        source_scene.do_on_exit_early()
+
+        self.current_transition :tuple[str,bf.transition.Transition]=(scene_name,transition,index)
+        transition.set_source(source_surface)
+        transition.set_dest(dest_surface)
+        transition.start()
+
+
+
+    def set_scene(self, scene_name, index=0, ignore_early: bool = False):
+        target_scene = self.get_scene(scene_name)
+        if not target_scene:
+            print(f"'{scene_name}' does not exist")
+            return
+        if len(self.scenes) == 0 or index >= len(self.scenes) or index < 0:
+            return
+
+        # switch
+        if not ignore_early:
+            self.scenes[index].do_on_exit_early()
+        self.scenes[index].on_exit()
+        # re-insert scene at index 0
+        self.scenes.remove(target_scene)
+        self.scenes.insert(index, target_scene)
+        _ = [s.set_scene_index(i) for i, s in enumerate(self.scenes)]
+        if not ignore_early:
+            self.scenes[index].do_on_enter_early()
+        target_scene.on_enter()
+
+
+
+    def cycle_debug_mode(self):
+        current_index = bf.ResourceManager().get_sharedVar("debug_mode").value
+        next_index = (current_index + 1) % len(bf.debugMode)
+        bf.ResourceManager().set_sharedVar("debug_mode", bf.debugMode(next_index))
+        return bf.debugMode(next_index)
+    
+    def set_debug_mode(self,debugMode : bf.debugMode):
+        bf.ResourceManager().set_sharedVar("debug_mode", debugMode)
+
+    def process_event(self, event: pygame.Event):
+
+        if event.type in self.shared_events:
+            [s.process_event(event) for s in self.scenes]
+        else:
+            self.scenes[0].process_event(event)
+
+    def update(self, dt: float) -> None:
+        for scene in self.active_scenes:
+            scene.update(dt)
+        if self.current_transition and self.current_transition[1].is_over:
+            self.set_scene(self.current_transition[0],self.current_transition[2],True)
+            self.current_transition = None
+        self.do_update(dt)
+
+    def do_update(self, dt: float):
+        pass
+
+    def draw(self, surface:pygame.Surface) -> None:
+        for scene in self.visible_scenes:
+            scene.draw(surface)
+        if self.current_transition is not None:
+            self.current_transition[1].set_source(surface)
+            tmp = surface.copy()
+            self.get_scene(self.current_transition[0]).draw(tmp)
+            self.current_transition[1].set_dest(tmp)
+            self.current_transition[1].draw(surface)
+

batFramework/scrollingSprite.py

@@ -1,115 +1,115 @@
-from typing import Self, Iterator
-from pygame.math import Vector2
-import batFramework as bf
-import pygame
-
-
-class ScrollingSprite(bf.Sprite):
-    def __init__(
-        self,
-        data: pygame.Surface | str,
-        size: None | tuple[int, int] = None,
-        convert_alpha: bool = True,
-    ):
-        self.scroll_value = Vector2(0, 0)
-        self.auto_scroll = Vector2(0, 0)
-
-        # Use integer values for the starting points, converted from floating point scroll values
-
-        super().__init__(size, data, convert_alpha)
-        if self.original_surface:
-            self.original_width, self.original_height = self.original_surface.get_size()
-
-
-    def get_debug_outlines(self):
-        yield from super().get_debug_outlines()
-        for r in self._get_mosaic_rect_list():
-            yield r.move(*self.rect.topleft)
-
-
-    def set_autoscroll(self, x: float, y: float) -> Self:
-        self.auto_scroll.update(x, y)
-        return self
-
-    def set_scroll(self, x: float = None, y: float = None) -> Self:
-        self.scroll_value.update(
-            x if x else self.scroll_value.x, y if y else self.scroll_value.y
-        )
-        return self
-
-    def scroll(self, x: float, y: float) -> Self:
-        self.scroll_value += x, y
-        return self
-
-    def update(self, dt: float) -> None:
-        if self.auto_scroll:
-            self.scroll(*self.auto_scroll * dt)
-        original_width, original_height = self.original_surface.get_size()
-
-        # Use integer values for the starting points, converted from floating point scroll values
-
-        if self.scroll_value.x > self.original_width:
-            self.scroll_value.x -= self.original_width
-        if self.scroll_value.y > self.original_height:
-            self.scroll_value.y -= self.original_height
-
-        super().update(dt)
-
-    def set_size(self, size: tuple[int | None, int | None]) -> Self:
-        size = list(size)
-        if size[0] is None:
-            size[0] = self.rect.w
-        if size[1] is None:
-            size[1] = self.rect.h
-
-        self.surface = pygame.Surface(size).convert_alpha()
-        self.rect = self.surface.get_frect(topleft=self.rect.topleft)
-        return self
-
-    def _get_mosaic_rect_list(self,camera:bf.Camera=None) -> Iterator[pygame.Rect]:
-        # Use integer values for the starting points, converted from floating point scroll values
-        start_x = int(self.scroll_value.x % self.original_width)
-        start_y = int(self.scroll_value.y % self.original_height)
-
-        # Adjust start_x and start_y to begin tiling off-screen to the top-left, covering all visible area
-        if start_x != 0:
-            start_x -= self.original_width
-        if start_y != 0:
-            start_y -= self.original_height
-
-        # Set the region in which to tile
-        end_x = self.rect.w
-        end_y = self.rect.h
-
-        # Starting y_position for the inner loop
-        y_position = start_y
-
-        # if self.rect.w-1 < self.scroll_value.x < self.rect.w+1 : print(self.scroll_value.x,int(self.scroll_value.x % self.rect.w),start_x,self.rect.w,original_width)
-        # Generate all necessary rectangles
-        x = start_x
-        while x < end_x:
-            y = y_position
-            while y < end_y:
-                r = pygame.Rect(x, y, self.original_width, self.original_height)
-                
-                if camera and camera.rect.colliderect((x+camera.rect.x,y+camera.rect.y,self.original_width,self.original_height)):
-                    yield r
-                else:
-                    yield r
-                y += self.original_height
-            x += self.original_width
-        return self
-
-    def draw(self, camera: bf.Camera) -> None:
-        if not (
-            self.visible
-            and (self.surface is not None)
-            and camera.rect.colliderect(self.rect)
-        ):
-            return
-        # self.surface.fill((0, 0, 0, 0))
-        camera.surface.fblits(
-            [(self.original_surface, r.move(self.rect.x-camera.rect.x,self.rect.y-camera.rect.y)) for r in self._get_mosaic_rect_list(camera)]
-        )
-        # camera.surface.blit(self.surface, camera.world_to_screen(self.rect))
-        return
+from typing import Self, Iterator
+from pygame.math import Vector2
+import batFramework as bf
+import pygame
+
+
+class ScrollingSprite(bf.Sprite):
+    def __init__(
+        self,
+        data: pygame.Surface | str,
+        size: None | tuple[int, int] = None,
+        convert_alpha: bool = True,
+    ):
+        self.scroll_value = Vector2(0, 0)
+        self.auto_scroll = Vector2(0, 0)
+
+        # Use integer values for the starting points, converted from floating point scroll values
+
+        super().__init__(size, data, convert_alpha)
+        if self.original_surface:
+            self.original_width, self.original_height = self.original_surface.get_size()
+
+
+    def get_debug_outlines(self):
+        yield from super().get_debug_outlines()
+        for r in self._get_mosaic_rect_list():
+            yield r.move(*self.rect.topleft)
+
+
+    def set_autoscroll(self, x: float, y: float) -> Self:
+        self.auto_scroll.update(x, y)
+        return self
+
+    def set_scroll(self, x: float = None, y: float = None) -> Self:
+        self.scroll_value.update(
+            x if x else self.scroll_value.x, y if y else self.scroll_value.y
+        )
+        return self
+
+    def scroll(self, x: float, y: float) -> Self:
+        self.scroll_value += x, y
+        return self
+
+    def update(self, dt: float) -> None:
+        if self.auto_scroll:
+            self.scroll(*self.auto_scroll * dt)
+        original_width, original_height = self.original_surface.get_size()
+
+        # Use integer values for the starting points, converted from floating point scroll values
+
+        if self.scroll_value.x > self.original_width:
+            self.scroll_value.x -= self.original_width
+        if self.scroll_value.y > self.original_height:
+            self.scroll_value.y -= self.original_height
+
+        super().update(dt)
+
+    def set_size(self, size: tuple[int | None, int | None]) -> Self:
+        size = list(size)
+        if size[0] is None:
+            size[0] = self.rect.w
+        if size[1] is None:
+            size[1] = self.rect.h
+
+        self.surface = pygame.Surface(size).convert_alpha()
+        self.rect = self.surface.get_frect(topleft=self.rect.topleft)
+        return self
+
+    def _get_mosaic_rect_list(self,camera:bf.Camera=None) -> Iterator[pygame.Rect]:
+        # Use integer values for the starting points, converted from floating point scroll values
+        start_x = int(self.scroll_value.x % self.original_width)
+        start_y = int(self.scroll_value.y % self.original_height)
+
+        # Adjust start_x and start_y to begin tiling off-screen to the top-left, covering all visible area
+        if start_x != 0:
+            start_x -= self.original_width
+        if start_y != 0:
+            start_y -= self.original_height
+
+        # Set the region in which to tile
+        end_x = self.rect.w
+        end_y = self.rect.h
+
+        # Starting y_position for the inner loop
+        y_position = start_y
+
+        # if self.rect.w-1 < self.scroll_value.x < self.rect.w+1 : print(self.scroll_value.x,int(self.scroll_value.x % self.rect.w),start_x,self.rect.w,original_width)
+        # Generate all necessary rectangles
+        x = start_x
+        while x < end_x:
+            y = y_position
+            while y < end_y:
+                r = pygame.Rect(x, y, self.original_width, self.original_height)
+                
+                if camera and camera.rect.colliderect((x+camera.rect.x,y+camera.rect.y,self.original_width,self.original_height)):
+                    yield r
+                else:
+                    yield r
+                y += self.original_height
+            x += self.original_width
+        return self
+
+    def draw(self, camera: bf.Camera) -> None:
+        if not (
+            self.visible
+            and (self.surface is not None)
+            and camera.rect.colliderect(self.rect)
+        ):
+            return
+        # self.surface.fill((0, 0, 0, 0))
+        camera.surface.fblits(
+            [(self.original_surface, r.move(self.rect.x-camera.rect.x,self.rect.y-camera.rect.y)) for r in self._get_mosaic_rect_list(camera)]
+        )
+        # camera.surface.blit(self.surface, camera.world_to_screen(self.rect))
+        return