batframework 1.0.8a2__py3-none-any.whl → 1.0.8a4__py3-none-any.whl

batFramework/time.py

@@ -1,75 +1,140 @@
-import pygame
 import batFramework as bf
+from typing import Self
+
 
 class Timer:
-    _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
+    _count: int = 0
+
+    def __init__(self, duration: float | int, end_callback, loop: bool = False, register="global") -> None:
+        self.name: int = Timer._count
+        Timer._count += 1
+        self.register = register
+        self.duration: int | float = duration
         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
 
-    def stop(self):
-        # Stop the timer
-        self.stopped = True
+        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 __repr__(self) -> str:
+        return f"Timer ({self.name}) {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 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
+
+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)
 
-    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
+class TimeManager(metaclass=bf.Singleton):
+    class TimerRegister:
+        def __init__(self, active=True):
+            self.active = active
+            self.timers: dict[int | str, Timer] = {}
 
+        def __iter__(self):
+            return iter(self.timers.values())
+
+        def add_timer(self, timer: Timer):
+            self.timers[timer.name] = 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.name)
+            for name in expired_timers:
+                del self.timers[name]
 
-class Time(metaclass=bf.Singleton):
     def __init__(self):
-        # Initialize the Time class with a dictionary of timers
-        self.timers = {}
+        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 add_timer(self, timer):
-        # Add a timer to the dictionary
-        self.timers[timer.name] = timer
+    def get_active_registers(self) -> list[TimerRegister]:
+        return [t for t in self.registers.values() if t.active]
 
-    def update(self):
-        # Update all timers and remove completed ones
-        for timer in list(self.timers.values()):
-            timer.update()
+    def update(self, dt):
+        for register_name, register in self.registers.items():
+            if register.active:
+                register.update(dt)
 
-        to_remove = [name for name, timer in self.timers.items() if timer.ended()]
+    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.")
 
-        for name in to_remove:
-            # print(self.timers.pop(name).name,"removed !")
-            self.timers.pop(name)
+    def deactivate_register(self, name):
+        self.activate_register(name, active=False)

batFramework/transition.py

@@ -1,157 +1,228 @@
-import pygame
 import batFramework as bf
+from typing import Self
+import pygame
+
+"""
+Both surfaces to transition need to be the same size
 
+"""
 
-class BaseTransition:
+
+class Transition:
+    def __init__(
+        self, duration: float, easing_function: bf.easing = bf.easing.LINEAR
+    ) -> None:
+        """
+        duration : time in seconds
+        easing function : controls the progression rate
+        """
+        self.duration: float = duration
+        self.controller = bf.EasingController(
+            easing_function,
+            duration,
+            update_callback=self.update,
+            end_callback=self.end,
+        )
+        self.start_callback = None
+        self.update_callback = None
+        self.end_callback = None
+        self.source: pygame.Surface = None
+        self.dest: pygame.Surface = None
+
+    def __repr__(self) -> str:
+        return f"Transition {self.__class__},{self.duration}"
+
+    def set_start_callback(self, func) -> Self:
+        self.start_callback = func
+        return self
+
+    def set_update_callback(self, func) -> Self:
+        self.update_callback = func
+        return self
+
+    def set_end_callback(self, func) -> Self:
+        self.end_callback = func
+        return self
+
+    def set_source(self, surface: pygame.Surface) -> None:
+        self.source = surface
+
+    def set_dest(self, surface: pygame.Surface) -> None:
+        self.dest = surface
+
+    def start(self):
+        if self.controller.has_started():
+            return
+        if self.duration:
+            self.controller.start()
+            if self.start_callback:
+                self.start_callback()
+            return
+
+        self.controller.start()
+        if self.start_callback:
+            self.start_callback()
+        self.controller.end()
+        self.update(1)
+        self.end()
+
+    def update(self, progression: float) -> None:
+        if self.update_callback:
+            self.update_callback(progression)
+
+    def end(self):
+        self.controller.stop()
+        if self.end_callback:
+            self.end_callback()
+
+    def draw(self, surface: pygame.Surface) -> None:
+        pass
+
+    def skip(self, no_callback: bool = False):
+        self.controller.stop()
+        if self.end_callback and (no_callback == False):
+            self.end_callback()
+
+
+class FadeColor(Transition):
     def __init__(
         self,
-        source_surf: pygame.Surface,
-        dest_surf: pygame.Surface,
-        duration=100,
-        **kwargs,
+        color: tuple,
+        middle_duration: float,
+        first_duration: float = None,
+        second_duration: float = None,
+        easing_function: bf.easing = bf.easing.LINEAR,
     ) -> None:
-        self.source = source_surf
-        self.dest = dest_surf
-        self.ended = False
-        self.source_scene_name = ""
-        self.dest_scene_name = ""
-        self.duration = duration
+        super().__init__(0, easing_function)
+        if first_duration is None:
+            first_duration = middle_duration
+        if second_duration is None:
+            second_duration = middle_duration
+
+        self.first = Fade(first_duration)
+        self.second = Fade(second_duration)
+        self.color = color
+        self.middle_duration = middle_duration
         self.index = 0
 
-    def set_scene_index(self,index):
-        self.index = index
+        self.timer = bf.Timer(middle_duration, self.transition_to_second)
+        self.first.set_end_callback(self.transition_to_middle)
+        self.second.set_end_callback(self.transition_to_end)
 
-    def set_source_name(self, name):
-        self.source_scene_name = name
+    def transition_to_middle(self):
+        self.next_step(self.timer.start)
 
-    def set_dest_name(self, name):
-        self.dest_scene_name = name
+    def transition_to_second(self):
+        self.next_step(self.second.start)
 
-    def update(self, dt):
-        pass
+    def transition_to_end(self):
+        self.next_step(self.end)
 
-    def draw(self, surface):
-        pass
+    def next_step(self, callback=None) -> None:
+        self.index += 1
+        if callback:
+            callback()
 
-    def has_ended(self):
-        return False
+    def set_source(self, surface) -> None:
+        super().set_source(surface)
+        self.first.set_source(surface)
 
-    def set_ended(self, val):
-        self.ended = val
+    def set_dest(self, surface) -> None:
+        super().set_dest(surface)
+        self.second.set_dest(surface)
 
+    def start(self):
+        if self.start_callback:
+            self.start_callback()
 
-class FadeColorTransition(BaseTransition):
-    def __init__(
-        self,
-        source_surf,
-        dest_surf,
-        duration=600,
-        color_duration=200,
-        color=bf.color.CLOUD_WHITE,
-        **kwargs,
-    ) -> None:
-        super().__init__(source_surf, dest_surf, duration)
-        self.target_time = duration * 2 + color_duration
-        self.color_surf = pygame.Surface((source_surf.get_rect().size)).convert_alpha()
-        self.color_surf.fill(color)
-        self.ease_out = bf.EasingAnimation(
-            easing_function=bf.Easing.EASE_IN,
-            duration=(duration-color_duration)//2,
-            update_callback = lambda x: self.color_surf.set_alpha(int(255 - (255 * x))),
-            end_callback=lambda: self.set_ended(True))
-
-        self.color_timer = bf.Timer(
-            duration=color_duration,
-            end_callback=lambda: self.set_state("out"))
-        self.ease_in = bf.EasingAnimation(
-            easing_function=bf.Easing.EASE_IN,
-            duration=(duration-color_duration)//2,
-            update_callback=lambda x: self.color_surf.set_alpha(int(255 * x)),
-            # update_callback=lambda x: print(x),
-            end_callback=lambda: self.set_state("color"))
-        self.state = None
-
-        self.state = "in"
-        self.ease_in.start()
-
-    def set_state(self, state: str):
-        self.state = state
-        if state == "in":
-            self.ease_in.start()
-        elif state == "color":
-            self.color_timer.start()
-        elif state == "out":
-            self.ease_out.start()
-
-    def has_ended(self):
-        return self.ended
-
-    def set_ended(self, val):
-        super().set_ended(val)
+        self.color_surf = pygame.Surface(self.source.get_size())
+        self.color_surf.fill(self.color)
+
+        self.first.set_dest(self.color_surf)
+        self.second.set_source(self.color_surf)
+        self.first.start()
 
     def draw(self, surface):
-        if self.state != "color":
-            surface.blit(self.source if self.state == "in" else self.dest, (0, 0))
-        surface.blit(self.color_surf, (0, 0))
+        if self.index == 0:
+            self.first.draw(surface)
+        elif self.index == 1:
+            surface.blit(self.color_surf, (0, 0))
+        else:
+            self.second.draw(surface)
 
+    def skip(self, no_callback: bool = False):
+        if not no_callback and self.end_callback:
+            self.end_callback()
 
-class FadeTransition(BaseTransition):
-    def __init__(self, source_surf, dest_surf, duration=500) -> None:
-        super().__init__(source_surf, dest_surf)
-        self.anim = bf.EasingAnimation(None,bf.Easing.EASE_IN_OUT,duration,self.update_surface,lambda : self.set_ended(True))
-        self.anim.start()
+        self.first.controller.stop()
+        self.timer.stop()
+        self.second.controller.stop()
 
-    def update_surface(self,progress):
-        self.source.set_alpha(int(255 - (255 * progress)))
-        self.dest.set_alpha(int(255 * progress))
 
-    def has_ended(self):
-        return self.ended
+
+class Fade(Transition):
+    def end(self):
+        self.dest.set_alpha(255)
+        return super().end()
 
     def draw(self, surface):
+        dest_alpha = 255 * self.controller.get_value()
+        self.dest.set_alpha(dest_alpha)
         surface.blit(self.source, (0, 0))
         surface.blit(self.dest, (0, 0))
 
 
-class SlideTransition(BaseTransition):
-    def __init__(
-        self,
-        source_surf,
-        dest_surf,
-        duration=1000,
-        source_alignment: bf.Alignment = bf.Alignment.BOTTOM,
-        easing: bf.Easing = bf.Easing.EASE_IN_OUT,
-        **kwargs,
-    ) -> None:
-        super().__init__(source_surf, dest_surf, duration)
-        self.offset = pygame.Vector2(0, 0)
-        if source_alignment in [bf.Alignment.TOP, bf.Alignment.BOTTOM]:
-            self.offset.y = bf.const.RESOLUTION[1]
-            if source_alignment == bf.Alignment.TOP:
-                self.offset.y *= -1
-        elif source_alignment in [bf.Alignment.LEFT, bf.Alignment.RIGHT]:
-            self.offset.x = bf.const.RESOLUTION[0]
-            if source_alignment == bf.Alignment.LEFT:
-                self.offset.x *= -1
-        else:
-            self.offset.x = -bf.const.RESOLUTION[0]
-            print(
-                f"Unsupported Alignment : {source_alignment.value}, set to default : {bf.Alignment.LEFT.value} "
-            )
-        self.anim = bf.EasingAnimation(
-            easing_function=easing,
-            duration=duration,
-            update_callback =lambda x: self.update_offset(self.offset.lerp((0, 0), x)),
-            end_callback =lambda: self.set_ended(True),
+class GlideRight(Transition):
+    def draw(self, surface):
+        width = surface.get_width()
+        source_x = -self.controller.get_value() * width
+        surface.blit(self.source, (source_x, 0))
+        surface.blit(self.dest, (width + source_x, 0))
+
+
+class GlideLeft(Transition):
+    def draw(self, surface):
+        width = surface.get_width()
+        source_x = self.controller.get_value() * width
+        surface.blit(self.source, (source_x, 0))
+        surface.blit(self.dest, (source_x - width, 0))
+
+
+class CircleOut(Transition):
+    def start(self):
+        super().start()
+        self.circle_surf = self.source.copy()
+        self.circle_surf.set_colorkey((0, 0, 0))
+        self.circle_surf.fill((0, 0, 0))
+        self.surface_width = self.circle_surf.get_width()
+
+    def draw(self, surface):
+        v = self.controller.get_value()
+
+        radius = self.surface_width * v
+        pygame.draw.circle(
+            self.circle_surf, "white", self.circle_surf.get_rect().center, radius
         )
-        self.anim.start()
+        mask = pygame.mask.from_surface(self.circle_surf)
+        mask.to_surface(surface=surface, setsurface=self.dest, unsetsurface=self.source)
 
-    def update_offset(self, vec):
-        self.offset.update(vec)
 
-    def has_ended(self):
-        return self.ended
+class CircleIn(Transition):
+    def start(self):
+        super().start()
+        self.circle_surf = self.source.copy()
+        self.circle_surf.set_colorkey((0, 0, 0))
+        self.circle_surf.fill((0, 0, 0))
+        self.surface_width = self.circle_surf.get_width()
 
     def draw(self, surface):
-        surface.blit(self.source, (0, 0))
-        surface.blit(self.dest, self.offset)
+        v = self.controller.get_value()
+        radius = self.surface_width - (self.surface_width * v)
+        self.circle_surf.fill((0, 0, 0))
+        pygame.draw.circle(
+            self.circle_surf, "white", self.circle_surf.get_rect().center, radius
+        )
+        mask = pygame.mask.from_surface(self.circle_surf)
+        mask.to_surface(surface=surface, setsurface=self.source, unsetsurface=self.dest)
+
+