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

batFramework/scrollingSprite.py

@@ -0,0 +1,113 @@
+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(center=self.rect.center)
+        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) -> int:
+        if not (
+            self.visible
+            and (self.surface is not None)
+            and camera.rect.colliderect(self.rect)
+        ):
+            return 0
+        self.surface.fill((0, 0, 0, 0))
+        self.surface.fblits(
+            [(self.original_surface, r) for r in self._get_mosaic_rect_list()]
+        )
+        # pygame.draw.rect(camera.surface,"green",next(self._get_mosaic_rect_list()).move(*self.rect.topleft),1)
+        camera.surface.blit(self.surface, camera.world_to_screen(self.rect))
+        return 1

batFramework/sprite.py

@@ -2,32 +2,44 @@ import batFramework as bf
 import pygame
 from typing import Self
 
-class Sprite(bf.DynamicEntity):
+
+class Sprite(bf.Entity):
     def __init__(
         self,
-        data: pygame.Surface | str,
+        path=None,
         size: None | tuple[int, int] = None,
         convert_alpha: bool = True,
     ):
-        self.original_surface = None
-        super().__init__(convert_alpha=convert_alpha)
-        if data:
-            self.set_image(data, size)
-    
-    def set_image(
-        self, data: pygame.Surface | str, size: None | tuple[int, int] = None
-    ):
-        if isinstance(data, str):
-            tmp = bf.ResourceManager().get_image(data,self.convert_alpha)
-            self.original_surface = tmp
-        elif isinstance(data, pygame.Surface):
-            self.original_surface = data
-        else:
-            raise ValueError("Image data can be either path or Surface")
-        if self.convert_alpha:
-            self.original_surface = self.original_surface.convert_alpha()
-        if not size:
-            size = self.original_surface.get_size()
-        self.surface = pygame.transform.scale(self.original_surface, size)
-        self.rect = self.surface.get_frect(center=self.rect.center)
+        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/tileset.py

@@ -1,64 +1,46 @@
 import pygame
-from .utils import Utils
 from .resourceManager import ResourceManager
+import batFramework as bf
 
-class Tileset:
-    _tilesets = {}
-    _flip_cache = {}  # {"tileset":tileset,"index","flipX","flipY"}
 
-    def __init__(self, source: pygame.Surface | str, tilesize) -> None:
-        if isinstance(source, str):
-            source = ResourceManager().get_image(source,convert_alpha=True)
 
-        self.tile_dict = {}
+class Tileset:
+    def __init__(self, source: pygame.Surface, tilesize: tuple[int, int]) -> None:
         self.surface = source
         self.tile_size = tilesize
-        self.split_surface(self.surface)
+        self.tile_width = source.get_width() // tilesize[0]
+        self.tile_height = source.get_height() // tilesize[1]
+        # Create flipped versions of the tileset surface
+        self.flipped_surfaces = {
+            (False, False): self.surface,
+            (False, True): pygame.transform.flip(self.surface, False, True),
+            (True, False): pygame.transform.flip(self.surface, True, False),
+            (True, True): pygame.transform.flip(self.surface, True, True),
+        }
+
+        # Split each of the surfaces into tiles
+        self.tile_dict = {}
+        for flip_state, surf in self.flipped_surfaces.items():
+            tiles = bf.utils.split_surface(surf, self.tile_size)
+            for coord, tile in tiles.items():
+                if coord not in self.tile_dict:
+                    self.tile_dict[coord] = {}
+                self.tile_dict[coord][flip_state] = tile
 
-    def split_surface(self, surface: pygame.Surface):
-        width, height = surface.get_size()
-        num_tiles_x = width // self.tile_size
-        num_tiles_y = height // self.tile_size
-        # Iterate over the tiles vertically and horizontally
-        for y in range(num_tiles_y):
-            for x in range(num_tiles_x):
-                # Calculate the coordinates of the current tile in the tileset
-                tile_x = x * self.tile_size
-                tile_y = y * self.tile_size
-                # Create a subsurface for the current tile
-                tile_surface = surface.subsurface(
-                    pygame.Rect(tile_x, tile_y, self.tile_size, self.tile_size)
-                )
-                # Calculate the unique key for the tile (e.g., based on its coordinates)
-                tile_key = (x, y)
-                # Store the subsurface in the dictionary with the corresponding key
-                self.tile_dict[tile_key] = tile_surface
-        # print(self.tile_dict)
 
-    def get_tile(self, x, y, flipX=False, flipY=False) -> pygame.Surface | None:
-        if (x, y) not in self.tile_dict:
-            return None
-        if flipX or flipY:
-            key = f"{x}{y}:{flipX}{flipY}"
-            if not key in self._flip_cache:
-                self._flip_cache[key] = pygame.transform.flip(
-                    self.tile_dict[(x, y)], flipX, flipY
-                )
-            return self._flip_cache[key]
-        return self.tile_dict[(x, y)]
+    def __str__(self)->str:
+        num_tiles = 0
+        if self.tile_dict:
+            num_tiles = len(self.tile_dict.values())
+        return f"{num_tiles} tiles | Tile size : {self.tile_size}"
 
-    @staticmethod
-    def load_tileset(path: str, name: str, tilesize) -> "Tileset":
-        if name in Tileset._tilesets:
-            return Tileset._tilesets[name]
-        else:
-            img = ResourceManager().get_image(path,convert_alpha=True)
-            tileset = Tileset(img, tilesize)
-            Tileset._tilesets[name] = tileset
-            return tileset
+    def get_tile(self, x, y, flipX=False, flipY=False) -> pygame.Surface | None:
 
-    @staticmethod
-    def get_tileset(name: str) -> "Tileset":
-        if name not in Tileset._tilesets:
+        if flipX:
+            x = self.tile_width - 1 - x
+        if flipY:
+            y = self.tile_height - 1 - y
+        tile_data = self.tile_dict.get((x, y), None)
+        if tile_data is None:
             return None
-        return Tileset._tilesets[name]
+        return tile_data.get((flipX, flipY), None)

batFramework/time.py

@@ -1,86 +1,135 @@
-import pygame
 import batFramework as bf
 from typing import Self
 
+
 class Timer:
-    _count :int = 0
-    def __init__(self,duration:float|int,end_callback,loop:bool=False)->None:
-        self.name = Timer._count
-        Timer._count+=1
+    _count: int = 0
+
+    def __init__(self, duration: float | int, end_callback, loop: bool = False) -> None:
+        self.name: int = Timer._count
+        Timer._count += 1
+
+        self.duration: int | float = duration
         self.end_callback = end_callback
-        self.duration : int|float = duration
-        self.paused : bool = False
-        self.elapsed_time : int = -1
-        self.over : bool = False  
-        self.do_delete:bool = False
-        self.is_looping :bool = loop 
-
-    def stop(self)->Self:
-        self.elapsed_time =-1
-        self.over = False
-        self.paused = 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 __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)->Self:
-        if self.elapsed_time >= 0 : 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):
+            return self
         self.elapsed_time = 0
-        self.paused = False
-        self.over = False
-        bf.TimeManager().add_timer(self)
+        self.is_paused = False
+        self.is_over = False
         return self
-        
-    def pause(self)->Self:
-        self.paused = True
+
+    def pause(self) -> Self:
+        self.is_paused = True
         return self
 
-    def resume(self)->Self:
-        self.paused = False
+    def resume(self) -> Self:
+        self.is_paused = False
         return self
-    def delete(self)->Self:
+
+    def delete(self) -> Self:
         self.do_delete = True
         return self
-    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.paused: return
+
+    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.end_callback()
+        if self.end_callback:
+            self.end_callback()
+        self.elapsed_time = -1
+        self.is_over = True
         if self.is_looping:
-            self.elapsed_time = -1
             self.start()
             return
-            
-        self.over = True
 
-    def has_ended(self)->bool:
-        return self.over or self.do_delete
+    def should_delete(self) -> bool:
+        return self.is_over or self.do_delete
+
+
+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 TimeManager(metaclass=bf.Singleton):
     def __init__(self):
-        # Initialize the TimeManager class with a dictionary of timers
-        self.timers = {}
+        self.registers = {"global": TimerRegister()}
 
-    def add_timer(self, timer):
-        # Add a timer to the dictionary
-        self.timers[timer.name] = timer
+    def add_register(self, name, active=True):
+        if name not in self.registers:
+            self.registers[name] = 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]
 
-    def update(self,dt):
-        # Update all timers and remove completed ones
-        timers = list(self.timers.values())
-        for timer in [t for t in timers if not t.paused]:
-            timer.update(dt)
+    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.has_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,3 +1,215 @@
-import pygame
 import batFramework as bf
+from typing import Self
+import pygame
+
+"""
+Both surfaces to transition need to be the same size
+
+"""
+
+
+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,
+        color: tuple | str,
+        middle_duration: float,
+        first_duration: float = None,
+        second_duration: float = None,
+        easing_function: bf.easing = bf.easing.LINEAR,
+    ) -> None:
+        super().__init__(0, easing_function)
+        if first_duration is None:
+            first_duration = middle_duration
+        if second_duration is None:
+            second_duration = middle_duration
+        self.index = 0
+        self.first = Fade(first_duration)
+        self.color = color
+        self.second = Fade(second_duration).set_end_callback(
+            lambda: self.next_step(self.end)
+        )
+        self.timer = bf.Timer(
+            middle_duration, lambda: self.next_step(self.second.start)
+        )
+        self.first.set_end_callback(lambda: self.next_step(self.timer.start))
+
+    def next_step(self, callback=None) -> None:
+        self.index += 1
+        if callback:
+            callback()
+
+    def set_source(self, surface) -> None:
+        super().set_source(surface)
+        self.first.set_source(surface)
+
+    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()
+        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.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 (no_callback == False) and self.end_callback:
+            self.end_callback()
+
+        self.first.controller.stop()
+        self.timer.stop()
+        self.second.controller.stop()
+
+
+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 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
+        )
+        mask = pygame.mask.from_surface(self.circle_surf)
+        mask.to_surface(surface=surface, setsurface=self.dest, unsetsurface=self.source)
+
+
+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):
+        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)