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

batFramework/sceneManager.py

@@ -1,227 +1,165 @@
 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.Scene] = []
-        self.shared_events = {pygame.WINDOWRESIZED}
+    def __init__(self, *initial_scenes: bf.Scene) -> None:
+        self._debugging = 0
+        self.sharedVarDict = {}
 
+        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] = {}
 
-    def init_scenes(self, *initial_scenes:bf.Scene):
-        for index, s in enumerate(initial_scenes):
+        self._scenes: list[bf.Scene] = list(initial_scenes)
+        for index,s in enumerate(self._scenes):
+            s.set_manager(self)
             s.set_scene_index(index)
-        for s in reversed(initial_scenes):
-            self.add_scene(s)
-        # self.scenes = list(initial_scenes)
-        self.set_scene(initial_scenes[0].get_name())
+            s.do_when_added()
+        self.set_scene(self._scenes[0]._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):
-            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]
+        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]
 
     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 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()
+    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)]
         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
         ):
-            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)
+            self.print_status()
+        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):
-        pass
+        return
 
     def draw(self, surface) -> None:
-        for scene in self.visible_scenes:
+        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:
             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/stateMachine.py

@@ -1,17 +1,18 @@
 import batFramework as bf
 
 
-class StateMachine: ...
+class StateMachine:
+    ...
 
 
 class State:
     def __init__(self, name: str) -> None:
         self.name = name
-        self.parent: bf.Entity | bf.AnimatedSprite = None
+        self.parent_entity: bf.Entity | bf.AnimatedSprite = None
         self.state_machine: StateMachine = None
 
-    def set_parent(self, parent: bf.Entity | bf.AnimatedSprite):
-        self.parent = parent
+    def set_parent_entity(self, parent_entity: bf.Entity | bf.AnimatedSprite):
+        self.parent_entity = parent_entity
 
     def set_stateMachine(self, stateMachine):
         self.state_machine = stateMachine
@@ -27,26 +28,22 @@ class State:
 
 
 class StateMachine:
-    def __init__(self, parent) -> None:
+    def __init__(self, parent_entity) -> None:
         self.states: dict[str, State] = {}
-        self.parent = parent
+        self.parent_entity = parent_entity
         self.current_state = None
 
     def add_state(self, state: State):
         self.states[state.name] = state
-        state.set_parent(self.parent)
+        state.set_parent_entity(self.parent_entity)
         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/time.py

@@ -1,162 +1,75 @@
+import pygame
 import batFramework as bf
-from typing import Self
-
-
-from typing import Callable, Union, Self
-
 
 class Timer:
-    _count: int = 0
-    _available_ids: set[int] = set()
-
-    def __init__(self, duration: Union[float, int], end_callback: Callable, loop: bool = False, register: str = "global") -> None:
-        if Timer._available_ids:
-            self.uid = Timer._available_ids.pop()
-        else:
-            self.uid = Timer._count
-            Timer._count += 1
-
-        self.register = register
-        self.duration: int | float = duration
+    _highest_count = 0
+    def __init__(self, name=None, duration=1000, loop=False, end_callback=None,reusable:bool=False):
+        # Initialize timer properties
+        self.start_time = None
+        self.stopped = True
+        self.name = name if name is not None else self._highest_count
+        Timer._highest_count += 1
+        self.duration = duration
+        self.loop = loop
+        self.elapsed_progress = 0.0
         self.end_callback = end_callback
+        self.reusable:bool = reusable
+    def start(self):
+        # Start the timer and set the start time
+        if self.start_time is None:
+            Time().add_timer(self)
+            
+        self.start_time = pygame.time.get_ticks()
+        self.stopped = False
+        self.elapsed_progress = 0.0
+        
+    def update(self):
+        if self.stopped : return False
+        current_time = pygame.time.get_ticks()
+        if self.elapsed_progress < 1:
+            # Calculate elapsed progress
+            self.elapsed_progress = (current_time - self.start_time) / self.duration            
+            if self.elapsed_progress >= 1:
+                # Timer has completed
+                self.end()
+                return True
+        elif self.loop:
+            # If looping, restart the timer
+             self.start()
+        return False
 
-        self.elapsed_time: float = -1
-        self.is_over: bool = False
-        self.is_looping: bool = loop
-        self.is_paused: bool = False
-        self.do_delete: bool = False
-
-    def __bool__(self)->bool:
-        return self.elapsed_time==-1 or self.is_over
-
-    def __str__(self) -> str:
-        return f"Timer ({self.uid}) {self.elapsed_time}/{self.duration} | {'loop ' if self.is_looping else ''} {'(D) ' if self.do_delete else ''}"
-
-    def stop(self) -> Self:
-        self.elapsed_time = -1
-        self.is_over = False
-        self.is_paused = False
-        return self
-
-    def start(self, force: bool = False) -> Self:
-        if self.elapsed_time != -1 and not force:
-            return self
-        if not bf.TimeManager().add_timer(self,self.register):
-            return self
-        self.elapsed_time = 0
-        self.is_paused = False
-        self.is_over = False
-        return self
-
-    def pause(self) -> Self:
-        self.is_paused = True
-        return self
-
-    def resume(self) -> Self:
-        self.is_paused = False
-        return self
-
-    def delete(self) -> Self:
-        self.do_delete = True
-        return self
-
-    def has_started(self) -> bool:
-        return self.elapsed_time != -1
-
-    def get_progression(self) -> float:
-        if self.elapsed_time < 0:
-            return 0
-        if self.elapsed_time >= self.duration:
-            return 1
-        return self.elapsed_time / self.duration
-
-    def update(self, dt) -> None:
-        if self.elapsed_time < 0 or self.is_paused or self.is_over:
-            return
-        self.elapsed_time += dt
-        # print("update :",self.elapsed_time,self.duration)
-        if self.get_progression() == 1:
-            self.end()
+    def stop(self):
+        # Stop the timer
+        self.stopped = True
 
     def end(self):
+        self.elapsed_progress = 1
+        self.stopped = False
         if self.end_callback:
             self.end_callback()
-        self.elapsed_time = -1
-        self.is_over = True
-        if self.is_looping:
-            self.start()
-            return
-
-    def should_delete(self) -> bool:
-        return self.is_over or self.do_delete
-
-    def _release_id(self):
-        Timer._available_ids.add(self.uid)
-
-
-class SceneTimer(Timer):
-    def __init__(self, duration: float | int, end_callback, loop: bool = False, scene_name:str = "global") -> None:
-        super().__init__(duration, end_callback, loop, scene_name)
 
-class TimeManager(metaclass=bf.Singleton):
-    class TimerRegister:
-        def __init__(self, active=True):
-            self.active = active
-            self.timers: dict[int | str, Timer] = {}
+    def ended(self):
+        if self.start_time is None:
+            return False
+        return (not self.loop) and (self.elapsed_progress >= 1) and (not self.stopped) and not self.reusable
 
-        def __iter__(self):
-            return iter(self.timers.values())
-
-        def add_timer(self, timer: Timer):
-            self.timers[timer.uid] = timer
-
-        def update(self, dt):
-            expired_timers = []
-            for timer in list(self.timers.values()):
-                if not timer.is_paused:
-                    timer.update(dt)
-                if timer.should_delete():
-                    expired_timers.append(timer.uid)
-            for uid in expired_timers:
-                self.timers[uid]._release_id()
-                del self.timers[uid]
 
+class Time(metaclass=bf.Singleton):
     def __init__(self):
-        self.registers = {"global": TimeManager.TimerRegister()}
-
-    def add_register(self, name, active=True):
-        if name not in self.registers:
-            self.registers[name] = TimeManager.TimerRegister(active)
-
-    def add_timer(self, timer, register="global") -> bool:
-        if register in self.registers:
-            self.registers[register].add_timer(timer)
-            return True
-        print(f"Register '{register}' does not exist.")
-        return False
-
-    def get_active_registers(self) -> list[TimerRegister]:
-        return [t for t in self.registers.values() if t.active]
+        # Initialize the Time class with a dictionary of timers
+        self.timers = {}
 
-    def update(self, dt):
-        for register_name, register in self.registers.items():
-            if register.active:
-                register.update(dt)
+    def add_timer(self, timer):
+        # Add a timer to the dictionary
+        self.timers[timer.name] = timer
 
-    def activate_register(self, name, active=True):
-        if name in self.registers:
-            self.registers[name].active = active
-        else:
-            print(f"Register '{name}' does not exist.")
+    def update(self):
+        # Update all timers and remove completed ones
+        for timer in list(self.timers.values()):
+            timer.update()
 
-    def deactivate_register(self, name):
-        self.activate_register(name, active=False)
+        to_remove = [name for name, timer in self.timers.items() if timer.ended()]
 
-    def __str__(self)->str:
-        res = "" 
-        for name,reg in self.registers.items():
-            if not reg.timers:continue
-            res +=name+"\n"
-            for t in reg.timers.values():
-                res +="\t"+str(t)+"\n"
-        return res
+        for name in to_remove:
+            # print(self.timers.pop(name).name,"removed !")
+            self.timers.pop(name)