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

batFramework/sceneManager.py

@@ -1,165 +1,227 @@
 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, *initial_scenes: bf.Scene) -> None:
-        self._debugging = 0
-        self.sharedVarDict = {}
+    def __init__(self) -> None:
+        self.scenes: list[bf.Scene] = []
+        self.shared_events = {pygame.WINDOWRESIZED}
 
-        self.transitions: list[bf.BaseTransition] = []
-        self.set_sharedVar("is_debugging_func", lambda: self._debugging)
-        self.set_sharedVar("in_transition", False)
         self.set_sharedVar("in_cutscene", False)
+        self.set_sharedVar("player_has_control", True)
+        self.old_player_control = True
+        self.debug_mode: bf.enums.debugMode = bf.debugMode.HIDDEN
+        self.current_transitions: dict[str, bf.transition.Transition] = {}
 
-        self._scenes: list[bf.Scene] = list(initial_scenes)
-        for index,s in enumerate(self._scenes):
-            s.set_manager(self)
+    def init_scenes(self, *initial_scenes:bf.Scene):
+        for index, s in enumerate(initial_scenes):
             s.set_scene_index(index)
-            s.do_when_added()
-        self.set_scene(self._scenes[0]._name)
+        for s in reversed(initial_scenes):
+            self.add_scene(s)
+        # self.scenes = list(initial_scenes)
+        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("-" * 40)
-        print([(s._name, s._active, s._visible,s.scene_index) for s in self._scenes])
-        print(f"[Debugging] = {self._debugging}")
-        print("---SHARED VARIABLES---")
-        _ = [
-            print(f"[{str(name)} = {str(value)}]")
-            for name, value in self.sharedVarDict.items()
-        ]
-        print("-" * 40)
-
-    def set_sharedVar(self, name, value) -> bool:
-        self.sharedVarDict[name] = value
-        return True
-
-    def get_sharedVar(self, name):
-        if name not in self.sharedVarDict:
-            return None
-        return self.sharedVarDict[name]
-    
-    def get_current_scene_name(self)-> str:
-        return self._scenes[0].name
-    
-    def get_current_scene(self)->bf.Scene:
-        return self._scenes[0]
+        """
+        Print detailed information about the current state of the scenes and shared variables.
+        """
+
+        def format_scene_info(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] = {self.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 set_sharedVar(self, name, value) -> None:
+        bf.ResourceManager().set_sharedVar(name,value)
+
+    def get_sharedVar(self, name, error_value=None):
+        return bf.ResourceManager().get_sharedVar(name, error_value)
+
+    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]
+        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):
+        if scene in self.scenes and not self.has_scene(scene.name):
             return
         scene.set_manager(self)
         scene.do_when_added()
-        self._scenes.insert(0, scene)
+        self.scenes.insert(0, scene)
 
     def remove_scene(self, name: str):
-        self._scenes = [s for s in self._scenes if s._name != name]
+        self.scenes = [s for s in self.scenes if s.name != name]
 
     def has_scene(self, name):
-        return any(name == scene._name for scene in self._scenes)
+        return any(name == scene.name for scene in self.scenes)
 
     def get_scene(self, name):
         if not self.has_scene(name):
             return None
-        for scene in self._scenes:
-            if scene._name == name:
+        for scene in self.scenes:
+            if scene.name == name:
                 return scene
 
-    def transition_to_scene(self, dest_scene_name, transition, **kwargs):
-        if not self.has_scene(dest_scene_name):
-            return False
-        source_surf = pygame.Surface(bf.const.RESOLUTION,pygame.SRCALPHA).convert_alpha()
-        dest_surf = pygame.Surface(bf.const.RESOLUTION,pygame.SRCALPHA).convert_alpha()
-
-        index = kwargs.pop("index",0)
-        #draw the surfaces
-        source_scenes = [s for s in self.visible_scenes if s.scene_index >= index and s._visible]
-        # source_scenes = self.visible_scenes
-        _ = [s.draw(source_surf) for s in source_scenes] 
-        # self._scenes[index].draw(source_surf)
-
-        # pygame.image.save_extended:(source_surf,"source_surface.png")
-        self.get_scene(dest_scene_name).draw(dest_surf)
-        # pygame.image.save_extended(dest_surf,"dest_surface.png")
-
-        # print(f"start transition from {self._scenes[index]._name} to {dest_scene_name}")
-
-        instance: bf.BaseTransition = transition(
-            source_surf, dest_surf, **kwargs
-        )
-        instance.set_scene_index(index)
-        instance.set_source_name(self._scenes[index]._name)
-        instance.set_dest_name(dest_scene_name)
-        self.transitions.append(instance)
-        self.set_sharedVar("in_transition", True)
-
-    def set_scene(self, name,index=0):
-        if len(self._scenes)==0 or not self.has_scene(name) or index>=len(self._scenes):return
-
-        target_scene = self.get_scene(name)
-        old_scene = self._scenes[index]
-
-        # print(f"switch from {old_scene._name} to  {target_scene._name} in index {index}")
-
-        #switch
-        old_scene.on_exit()
-        self.remove_scene(name)
-        self._scenes.insert(index,target_scene)
-        _ = [s.set_scene_index(i) for i,s in enumerate(self._scenes)]
+    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 = bf.transition.Fade(0.1),
+        index: int = 0,
+    ):
+        target_scene = self.get_scene(scene_name)
+        if not target_scene:
+            print(f"Scene '{scene_name}' does not exist")
+            return
+        if len(self.scenes) == 0 or index >= len(self.scenes) or index < 0:
+            return
+        source_surface = bf.const.SCREEN.copy()
+        dest_surface = bf.const.SCREEN.copy()
+
+        # self.draw(source_surface)
+        target_scene.draw(dest_surface)
+        target_scene.do_on_enter_early()
+        self.get_scene_at(index).do_on_exit_early()
+        self.current_transitions = {"scene_name": scene_name, "transition": transition}
+        transition.set_start_callback(lambda: self._start_transition(target_scene))
+        transition.set_end_callback(lambda: self._end_transition(scene_name, index))
+        transition.set_source(source_surface)
+        transition.set_dest(dest_surface)
+        transition.start()
+
+    def _start_transition(self, target_scene: bf.Scene):
+        target_scene.set_active(True)
+        target_scene.set_visible(True)
+        self.old_player_control = bool(self.get_sharedVar("player_has_control"))
+        self.set_sharedVar("player_has_control", False)
+
+    def _end_transition(self, scene_name, index):
+        self.set_scene(scene_name, index, True)
+        self.current_transitions.clear()
+
+    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()
 
+        self.set_sharedVar("player_has_control", self.old_player_control)
+
+
+    def cycle_debug_mode(self):
+        current_index = self.debug_mode.value
+        next_index = (current_index + 1) % len(bf.debugMode)
+        return bf.debugMode(next_index)
 
     def process_event(self, event: pygame.Event):
-        if self.transitions:
-            return
         keys = pygame.key.get_pressed()
         if (
             keys[pygame.K_LCTRL]
+            and keys[pygame.K_LSHIFT]
             and event.type == pygame.KEYDOWN
-            and event.key == pygame.K_d
-        ):
-            self._debugging = (self._debugging + 1) % 3
-            return
-        elif (
-            keys[pygame.K_LCTRL]
-            and event.type == pygame.KEYDOWN
-            and event.key == pygame.K_p
         ):
-            self.print_status()
-        self._scenes[0].process_event(event)
+            if event.key == pygame.K_d:
+                self.debug_mode = self.cycle_debug_mode()
+                self.set_sharedVar("debug_mode", self.debug_mode)
+                return
+            if event.key == pygame.K_p:
+                self.print_status()
+                return
+        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:
-        if self.transitions:
-            transition = self.transitions[0]
-            transition.update(dt)
-            if transition.has_ended():
-                self.set_sharedVar("in_transition", False)
-                self.set_scene(transition.dest_scene_name,transition.index)
-
-                self.transitions.pop(0)
-            return
         for scene in self.active_scenes:
             scene.update(dt)
         self.do_update(dt)
 
     def do_update(self, dt: float):
-        return
+        pass
 
     def draw(self, surface) -> None:
-        transition_scene_index = -1
-        visible_scenes = self.visible_scenes.copy()
-        if self.transitions:
-            transition_scene_index = self.transitions[0].index
-            
-        if transition_scene_index >=0:
-            self.transitions[0].draw(surface)
-            visible_scenes = [s  for s in visible_scenes if s.scene_index < transition_scene_index]
-
-        for scene in visible_scenes:
+        for scene in self.visible_scenes:
             scene.draw(surface)
+        if self.current_transitions:
+            self._draw_transition(surface)
+
+    def _draw_transition(self, surface):
+        self.current_transitions["transition"].set_source(surface)
+        tmp = bf.const.SCREEN.copy()
+        self.get_scene(self.current_transitions["scene_name"]).draw(tmp)
+        self.current_transitions["transition"].set_dest(tmp)
+        self.current_transitions["transition"].draw(surface)
+        return

batFramework/scrollingSprite.py

@@ -0,0 +1,114 @@
+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__(data, size, convert_alpha)
+        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_image(
+        self, data: pygame.Surface | str, size: None | tuple[int, int] = None
+    ) -> Self:
+        super().set_image(data, size)
+        self.original_width, self.original_height = self.original_surface.get_size()
+        return self
+
+    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) -> 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:
+                yield pygame.Rect(x, y, self.original_width, self.original_height)
+                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.surface.blit(self.surface, camera.world_to_screen(self.rect))
+        return

batFramework/sprite.py

@@ -0,0 +1,51 @@
+import batFramework as bf
+import pygame
+from typing import Self
+
+
+class Sprite(bf.Entity):
+    def __init__(
+        self,
+        path=None,
+        size: None | tuple[int, int] = None,
+        convert_alpha: bool = True,
+    ):
+        self.original_surface: pygame.Surface = None
+
+        super().__init__(convert_alpha=convert_alpha)
+        if path is not None:
+            self.from_path(path)
+        if size is not None and self.original_surface:
+            self.set_size(self.original_surface.get_size())
+
+    def set_size(self, size: tuple[float, float]) -> Self:
+        if size == self.rect.size:
+            return self
+        self.rect.size = size
+        self.surface = pygame.Surface(
+            (int(self.rect.w), int(self.rect.h)), self.surface_flags
+        )
+        if self.convert_alpha:
+            self.surface = self.surface.convert_alpha()
+        self.surface.fill((0, 0, 0, 0 if self.convert_alpha else 255))
+        self.surface.blit(
+            pygame.transform.scale(self.original_surface, self.rect.size), (0, 0)
+        )
+        return self
+
+    def from_path(self, path: str) -> Self:
+        tmp = bf.ResourceManager().get_image(path, self.convert_alpha)
+        if tmp is None:
+            return self
+        self.original_surface = tmp
+        size = self.original_surface.get_size()
+        self.set_size(size)
+        return self
+
+    def from_surface(self, surface: pygame.Surface) -> Self:
+        if surface is None:
+            return self
+        self.original_surface = surface
+        size = self.original_surface.get_size()
+        self.set_size(size)
+        return self

batFramework/stateMachine.py

@@ -1,18 +1,17 @@
 import batFramework as bf
 
 
-class StateMachine:
-    ...
+class StateMachine: ...
 
 
 class State:
     def __init__(self, name: str) -> None:
         self.name = name
-        self.parent_entity: bf.Entity | bf.AnimatedSprite = None
+        self.parent: bf.Entity | bf.AnimatedSprite = None
         self.state_machine: StateMachine = None
 
-    def set_parent_entity(self, parent_entity: bf.Entity | bf.AnimatedSprite):
-        self.parent_entity = parent_entity
+    def set_parent(self, parent: bf.Entity | bf.AnimatedSprite):
+        self.parent = parent
 
     def set_stateMachine(self, stateMachine):
         self.state_machine = stateMachine
@@ -28,22 +27,26 @@ class State:
 
 
 class StateMachine:
-    def __init__(self, parent_entity) -> None:
+    def __init__(self, parent) -> None:
         self.states: dict[str, State] = {}
-        self.parent_entity = parent_entity
+        self.parent = parent
         self.current_state = None
 
     def add_state(self, state: State):
         self.states[state.name] = state
-        state.set_parent_entity(self.parent_entity)
+        state.set_parent(self.parent)
         state.set_stateMachine(self)
 
+    def remove_state(self,state_name: str):
+        self.states.pop(state_name,default=None)
+
     def set_state(self, state_name: str):
         if state_name in self.states:
             if self.current_state:
                 self.current_state.on_exit()
             self.current_state = self.states[state_name]
             self.current_state.on_enter()
+
     def get_current_state(self) -> State:
         return self.current_state
 

batFramework/templates/__init__.py

@@ -0,0 +1,2 @@
+from .character import *
+from .states import *

batFramework/templates/character.py

@@ -0,0 +1,44 @@
+import batFramework as bf
+import pygame
+from .states import *
+
+class Platform2DCharacter(bf.Character):
+    def __init__(self):
+        super().__init__()
+        self.actions = bf.ActionContainer(
+            *bf.DirectionalKeyControls(),
+            bf.Action("jump").add_key_control(pygame.K_SPACE).set_holding()
+        )
+        self.on_ground : bool = False
+        self.max_jumps = 2
+        self.jump_counter = 0
+        self.jump_force = 150
+        self.speed = 100
+        self.acceleration = 30
+        self.friction = 0.7
+        self.gravity = 300
+        self.terminal_velocity = 1000
+        self.state_machine.set_state("idle")
+        
+
+    def do_setup_animations(self):
+        self.add_animation(bf.Animation("idle"))
+        self.add_animation(bf.Animation("run"))
+        self.add_animation(bf.Animation("jump"))
+        self.add_animation(bf.Animation("fall"))
+
+
+    def do_setup_states(self):
+        self.state_machine.add_state(Platform2DIdle())
+        self.state_machine.add_state(Platform2DRun())
+        self.state_machine.add_state(Platform2DJump())
+        self.state_machine.add_state(Platform2DFall())
+
+
+
+    def do_reset_actions(self) -> None:
+        self.actions.reset()
+
+    def do_process_actions(self, event: pygame.Event) -> None:
+        self.actions.process_event(event)
+