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

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 = None,
+        second_duration: float | None = 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)
+
+

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.RIVER_BLUE)
+        self.set_debug_color(bf.color.RED)
         self.active = active
         self.callback = callback
         self.trigger = trigger

batFramework/utils.py

@@ -3,9 +3,14 @@ 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 = {}
@@ -16,169 +21,129 @@ class Singleton(type):
         return cls._instances[cls]
 
 
-class Direction(Enum):
-    HORIZONTAL = "horizontal"
-    VERTICAL = "vertical"
-
-
-class Alignment(Enum):
-    LEFT = "left"
-    RIGHT = "right"
-    CENTER = "center"
-    TOP = "top"
-    BOTTOM = "bottom"
+class Utils:
 
+    @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
 
-class Layout(Enum):
-    FILL = "fill"
-    FIT = "fit"
+        return res
 
+    @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")
 
-class Utils:
-    pygame.font.init()
-    FONTS = {}
-    tilesets = {}
+        def filter_function(s: str) -> str:
+            return pattern.sub("", s)
 
-    @staticmethod
-    def get_path(path: str):
-        return os.path.join(bf.const.RESOURCE_PATH, path)
+        return filter_function
 
-    @staticmethod
-    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 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)
+    @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
 
     @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)  
-              
+    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)
 
     @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)]
+    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]
 
-    @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 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
 
-    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
+            # 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 get_tileset(name: str) -> Tileset:
-        if name not in Utils.tilesets:
-            return None
-        return Utils.tilesets[name]
+            # Set the entity's new position
+            entity.set_center(new_x, new_y)
 
+        return update_position
 
+    @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 move_points(delta, *points):
-    res = []
-    for point in points:
-        res.append((point[0] + delta[0], point[1] + delta[1]))
-    return res

batframework-1.0.8a10.dist-info/LICENCE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [2023] [TURAN BATURAY]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.