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

batFramework/transition.py

@@ -1,228 +1,157 @@
-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()
+import batFramework as bf
 
 
-class FadeColor(Transition):
+class BaseTransition:
     def __init__(
         self,
-        color: tuple,
-        middle_duration: float,
-        first_duration: float | None = None,
-        second_duration: float | None = None,
-        easing_function: bf.easing = bf.easing.LINEAR,
+        source_surf: pygame.Surface,
+        dest_surf: pygame.Surface,
+        duration=100,
+        **kwargs,
     ) -> 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.first = Fade(first_duration)
-        self.second = Fade(second_duration)
-        self.color = color
-        self.middle_duration = middle_duration
+        self.source = source_surf
+        self.dest = dest_surf
+        self.ended = False
+        self.source_scene_name = ""
+        self.dest_scene_name = ""
+        self.duration = duration
         self.index = 0
 
-        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 transition_to_middle(self):
-        self.next_step(self.timer.start)
+    def set_scene_index(self,index):
+        self.index = index
 
-    def transition_to_second(self):
-        self.next_step(self.second.start)
+    def set_source_name(self, name):
+        self.source_scene_name = name
 
-    def transition_to_end(self):
-        self.next_step(self.end)
+    def set_dest_name(self, name):
+        self.dest_scene_name = name
 
-    def next_step(self, callback=None) -> None:
-        self.index += 1
-        if callback:
-            callback()
+    def update(self, dt):
+        pass
 
-    def set_source(self, surface) -> None:
-        super().set_source(surface)
-        self.first.set_source(surface)
+    def draw(self, surface):
+        pass
 
-    def set_dest(self, surface) -> None:
-        super().set_dest(surface)
-        self.second.set_dest(surface)
+    def has_ended(self):
+        return False
 
-    def start(self):
-        if self.start_callback:
-            self.start_callback()
+    def set_ended(self, val):
+        self.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()
+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)
 
     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)
+        if self.state != "color":
+            surface.blit(self.source if self.state == "in" else self.dest, (0, 0))
+        surface.blit(self.color_surf, (0, 0))
 
-    def skip(self, no_callback: bool = False):
-        if not no_callback and self.end_callback:
-            self.end_callback()
 
-        self.first.controller.stop()
-        self.timer.stop()
-        self.second.controller.stop()
+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()
 
+    def update_surface(self,progress):
+        self.source.set_alpha(int(255 - (255 * progress)))
+        self.dest.set_alpha(int(255 * progress))
 
-
-class Fade(Transition):
-    def end(self):
-        self.dest.set_alpha(255)
-        return super().end()
+    def has_ended(self):
+        return self.ended
 
     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
+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),
         )
-        mask = pygame.mask.from_surface(self.circle_surf)
-        mask.to_surface(surface=surface, setsurface=self.dest, unsetsurface=self.source)
+        self.anim.start()
 
+    def update_offset(self, vec):
+        self.offset.update(vec)
 
-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 has_ended(self):
+        return self.ended
 
     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)
-
-
+        surface.blit(self.source, (0, 0))
+        surface.blit(self.dest, self.offset)

batFramework/triggerZone.py

@@ -4,7 +4,7 @@ import batFramework as bf
 class TriggerZone(bf.Entity):
     def __init__(self, size, trigger, callback, active=True) -> None:
         super().__init__(size, True)
-        self.set_debug_color(bf.color.RED)
+        self.set_debug_color(bf.color.RIVER_BLUE)
         self.active = active
         self.callback = callback
         self.trigger = trigger

batFramework/utils.py

@@ -3,14 +3,9 @@ from enum import Enum
 import os
 import batFramework as bf
 import json
-from .enums import *
-import re
-from typing import Callable, TYPE_CHECKING, Any
-from functools import cache
-if TYPE_CHECKING:
-    from .object import Object
-    from .entity import Entity
 
+MAX_FONT_SIZE = 100
+MIN_FONT_SIZE = 8
 
 class Singleton(type):
     _instances = {}
@@ -21,129 +16,169 @@ class Singleton(type):
         return cls._instances[cls]
 
 
-class Utils:
+class Direction(Enum):
+    HORIZONTAL = "horizontal"
+    VERTICAL = "vertical"
 
-    @staticmethod
-    def split_surface(
-        surface: pygame.Surface, split_size: tuple[int, int], func=None
-    ) -> dict[tuple[int, int], pygame.Surface]:
-        """
-        Splits a surface into subsurfaces and returns a dictionnary of them
-        with their tuple coordinates as keys.
-        Exemple : '(0,0) : Surface'
-        """
-        width, height = surface.get_size()
-        res = {}
-        for iy, y in enumerate(range(0, height, split_size[1])):
-            for ix, x in enumerate(range(0, width, split_size[0])):
-                sub = surface.subsurface((x, y, split_size[0], split_size[1]))
-
-                if func is not None:
-                    sub = func(sub)
-
-                res[(ix, iy)] = sub
 
-        return res
+class Alignment(Enum):
+    LEFT = "left"
+    RIGHT = "right"
+    CENTER = "center"
+    TOP = "top"
+    BOTTOM = "bottom"
 
-    @staticmethod
-    def filter_text(text_mode: textMode):
-        if text_mode == textMode.ALPHABETICAL:
-            pattern = re.compile(r"[^a-zA-Z]")
-        elif text_mode == textMode.NUMERICAL:
-            pattern = re.compile(r"[^0-9]")
-        elif text_mode == textMode.ALPHANUMERICAL:
-            pattern = re.compile(r"[^a-zA-Z0-9]")
-        else:
-            raise ValueError("Unsupported text mode")
 
-        def filter_function(s: str) -> str:
-            return pattern.sub("", s)
+class Layout(Enum):
+    FILL = "fill"
+    FIT = "fit"
 
-        return filter_function
 
+class Utils:
+    pygame.font.init()
+    FONTS = {}
+    tilesets = {}
 
     @staticmethod
-    @cache
-    def create_spotlight(inside_color, outside_color, radius, radius_stop=None, dest_surf=None,size=None):
-        """
-        Draws a circle spotlight centered on a surface
-        inner color on the center
-        gradient towards outside color from radius to radius stop
-        surface background is made transparent
-        if des_surf is None:
-            if size is None :  size is radius_stop*radius_stop
-            returns the newly created surface of size 'size' with the spotlight drawn
-
-        """
-        if radius_stop is None:
-            radius_stop = radius
-        diameter = radius_stop * 2
-
-        if dest_surf is None:
-            if size is None:
-                size = (diameter,diameter)
-            dest_surf = pygame.Surface(size, pygame.SRCALPHA)
-        
-        dest_surf.fill((0,0,0,0))
-
-
-        center = dest_surf.get_rect().center
-
-        if radius_stop != radius:
-            for r in range(radius_stop, radius - 1, -1):
-                color = [
-                    inside_color[i] + (outside_color[i] - inside_color[i]) * (r - radius) / (radius_stop - radius)
-                    for i in range(3)
-                ] + [255]  # Preserve the alpha channel as fully opaque
-                pygame.draw.circle(dest_surf, color, center, r)
-        else:
-            pygame.draw.circle(dest_surf, inside_color, center, radius)
-
-        return dest_surf
+    def get_path(path: str):
+        return os.path.join(bf.const.RESOURCE_PATH, path)
 
     @staticmethod
-    def draw_spotlight(dest_surf:pygame.Surface,inside_color,outside_color,radius,radius_stop=None,center=None):
-        if radius_stop is None:
-            radius_stop = radius
-        center = dest_surf.get_rect().center if center is None else center
-        if radius_stop != radius:
-            for r in range(radius_stop, radius - 1, -1):
-                color = [
-                    inside_color[i] + (outside_color[i] - inside_color[i]) * (r - radius) / (radius_stop - radius)
-                    for i in range(3)
-                ] + [255]
-                pygame.draw.circle(dest_surf, color, center, r)
-        else:
-            pygame.draw.circle(dest_surf, inside_color, center, radius)
+    def load_json_from_file(path: str) -> dict:
+        try:
+            with open(Utils.get_path(path), "r") as file:
+                data = json.load(file)
+            return data
+        except FileNotFoundError:
+            print(f"File '{path}' not found")
+            return None
 
     @staticmethod
-    def animate_move(entity:"Object", start_pos : tuple[float,float], end_pos:tuple[float,float])->Callable[[float],None]:
-        def func(x):
-            entity.set_center(start_pos[0]+(end_pos[0]-start_pos[0])*x,start_pos[1]+(end_pos[1]-start_pos[1])*x)
-        return func
-    
-    def animate_move_to(entity: "Object", end_pos: tuple[float, float]) -> Callable[[float], None]:
-        # Start position will be captured once when the animation starts
-        start_pos = [None]
+    def save_json_to_file(path: str, data) -> bool:
+        try:
+            with open(Utils.get_path(path), "w") as file:
+                json.dump(data, file, indent=2)
+            return True
+        except FileNotFoundError:
+            return False
+            
+    @staticmethod
+    def init_font(raw_path:str):
+            try :
+                if raw_path is not None:
+                    Utils.load_font(raw_path if raw_path else None,None)
+                Utils.load_font(raw_path)
+            except FileNotFoundError:
+                Utils.load_sysfont(raw_path)
+                Utils.load_sysfont(raw_path,None)
 
-        def update_position(progression: float):
-            if start_pos[0] is None:
-                start_pos[0] = entity.rect.center  # Capture the start position at the start of the animation
 
-            # Calculate new position based on progression
-            new_x = start_pos[0][0] + (end_pos[0] - start_pos[0][0]) * progression
-            new_y = start_pos[0][1] + (end_pos[1] - start_pos[0][1]) * progression
+    @staticmethod
+    def load_font(path:str,name:str=''):
+        if path is not None: path = Utils.get_path(path) # convert path if given
+        filename = os.path.basename(path).split('.')[0] if path is not None else None # get filename if path is given, else None
+        if name != '' : filename = name # if name is not given, name is the filename
+        Utils.FONTS[filename] = {}
+        # fill the dict 
+        for size in range(MIN_FONT_SIZE, MAX_FONT_SIZE, 2):
+            Utils.FONTS[filename][size] = pygame.font.Font(path,size=size)
+
+    def load_sysfont(font_name:str,key:str=''):
+        if key == '' : key = font_name
+        if pygame.font.match_font(font_name) is None: 
+            raise FileNotFoundError(f"Requested font '{font_namey}' was not found")
+        Utils.FONTS[font_name] = {}
+
+        for size in range(MIN_FONT_SIZE, MAX_FONT_SIZE, 2):
+            Utils.FONTS[key][size] = pygame.font.SysFont(font_name,size=size)  
+              
 
-            # Set the entity's new position
-            entity.set_center(new_x, new_y)
+    @staticmethod
+    def get_font(name:str|None=None,text_size:int=12) -> pygame.Font:
+        if not name in Utils.FONTS: return None
+        if not text_size in Utils.FONTS[name]: return None
+        return Utils.FONTS[name][text_size]
+
+    class Tileset:
+        _flip_cache = {}  # {"tileset":tileset,"index","flipX","flipY"}
+
+        def __init__(self, surface: pygame.Surface, tilesize) -> None:
+            self.tile_dict = {}
+            self.surface = surface
+            self.tile_size = tilesize
+            self.split_surface(surface)
+
+        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)]
 
-        return update_position
+    @staticmethod
+    def img_slice(file, cell_width, cell_height, flipX=False) -> list[pygame.Surface]:
+        src = pygame.image.load(
+            os.path.join(bf.const.RESOURCE_PATH, file)
+        ).convert_alpha()
+        width, height = src.get_size()
+        res = []
+        for y in range(0, height, cell_height):
+            for x in range(0, width, cell_width):
+                sub = src.subsurface((x, y, cell_width, cell_height))
+                if flipX:
+                    sub = pygame.transform.flip(sub, True, False)
+
+                res.append(sub)
+        return res
+
+    def load_tileset(path: str, name: str, tilesize):
+        if name in Utils.tilesets:
+            return Utils.tilesets[name]
+        else:
+            img = pygame.image.load(
+                os.path.join(bf.const.RESOURCE_PATH, path)
+            ).convert_alpha()
+            tileset = Utils.Tileset(img, tilesize)
+            Utils.tilesets[name] = tileset
+            return tileset
 
     @staticmethod
-    def animate_alpha(entity:"Entity", start : int, end:int)->Callable[[float],None]:
-        def func(x):
-            entity.set_alpha(int(pygame.math.clamp(start+(end-start)*x,0,255)))
-        return func
+    def get_tileset(name: str) -> Tileset:
+        if name not in Utils.tilesets:
+            return None
+        return Utils.tilesets[name]
+
+
     
 
 
+def move_points(delta, *points):
+    res = []
+    for point in points:
+        res.append((point[0] + delta[0], point[1] + delta[1]))
+    return res