batframework 1.0.9a11__py3-none-any.whl → 1.1.0__py3-none-any.whl

batFramework/utils.py

@@ -1,16 +1,11 @@
 import pygame
+from enum import Enum
+import os
 import batFramework as bf
-import math
-import random
-from .enums import *
-import re
-from typing import Callable, TYPE_CHECKING
-from functools import cache
-if TYPE_CHECKING:
-    from .drawable import Drawable
-    from .entity import Entity
-from pygame.math import Vector2
+import json
 
+MAX_FONT_SIZE = 100
+MIN_FONT_SIZE = 8
 
 class Singleton(type):
     _instances = {}
@@ -21,286 +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 based on a given size and returns a dictionary of them with their coordinates as keys.
 
-        Args:
-            surface (pygame.Surface): The surface to be split.
-            split_size (tuple[int, int]): The size of each subsurface (width, height).
-            func (callable, optional): A function to apply to each subsurface. Defaults to None.
+class Alignment(Enum):
+    LEFT = "left"
+    RIGHT = "right"
+    CENTER = "center"
+    TOP = "top"
+    BOTTOM = "bottom"
 
-        Returns:
-            dict[tuple[int, int], pygame.Surface]: A dictionary with (x, y) coordinates as keys and the corresponding subsurfaces as values.
-        """
-        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)
+class Layout(Enum):
+    FILL = "fill"
+    FIT = "fit"
 
-                res[(ix, iy)] = sub
 
-        return res
+class Utils:
+    pygame.font.init()
+    FONTS = {}
+    tilesets = {}
 
     @staticmethod
-    def filter_text(text_mode: textMode):
-        """
-        Filters a string based on the specified text mode.
-
-        Args:
-            text_mode (textMode): Mode specifying the type of filtering (ALPHABETICAL, NUMERICAL, ALPHANUMERICAL).
-
-        Returns:
-            callable: A function that takes a string and removes all characters not allowed by the text mode.
-
-        Raises:
-            ValueError: If an unsupported text mode is provided.
-        """
-
-        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)
-
-        return filter_function
-
+    def get_path(path: str):
+        return os.path.join(bf.const.RESOURCE_PATH, path)
 
     @staticmethod
-    def create_spotlight(inside_color, outside_color, radius, radius_stop=None, dest_surf=None,size=None):
-        """
-        Creates a spotlight effect on a surface with a gradient from inside_color to outside_color.
-
-        Args:
-            inside_color (tuple[int, int, int]): RGB color at the center of the spotlight.
-            outside_color (tuple[int, int, int]): RGB color at the outer edge of the spotlight.
-            radius (int): Radius of the inner circle.
-            radius_stop (int, optional): Radius where the spotlight ends. Defaults to the value of radius.
-            dest_surf (pygame.Surface, optional): Surface to draw the spotlight on. Defaults to None.
-            size (tuple[int, int], optional): Size of the surface if dest_surf is None. Defaults to a square based on radius_stop.
-
-        Returns:
-            pygame.Surface: The surface with the spotlight effect drawn on it.
-        """
-
-        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 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 draw_spotlight(dest_surf:pygame.Surface,inside_color,outside_color,radius,radius_stop=None,center=None):
-        """
-        Draws a spotlight effect directly onto an existing surface.
-
-        Args:
-            dest_surf (pygame.Surface): The surface to draw the spotlight on.
-            inside_color (tuple[int, int, int]): RGB color at the center of the spotlight.
-            outside_color (tuple[int, int, int]): RGB color at the outer edge of the spotlight.
-            radius (int): Radius of the inner circle.
-            radius_stop (int, optional): Radius where the spotlight ends. Defaults to the value of radius.
-            center (tuple[int, int], optional): Center point of the spotlight. Defaults to the center of dest_surf.
-        """
-
-        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 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 random_color(min_value: int = 0, max_value: int = 255) -> tuple[int, int, int]:
-        """
-        Generates a random color as an RGB tuple.
+    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)
 
-        Args:
-            min_value (int): Minimum value for each RGB component (inclusive). Defaults to 0.
-            max_value (int): Maximum value for each RGB component (inclusive). Defaults to 255.
-
-        Returns:
-            tuple[int, int, int]: A tuple representing a random color in RGB format, with each component 
-            between min_value and max_value.
-        """
-        return random.randint(min_value, max_value), random.randint(min_value, max_value), random.randint(min_value, max_value)
 
     @staticmethod
-    def random_point_on_screen(margin: int = 0) -> tuple[int, int]:
-        """
-        Generates a random point on the screen, considering a margin from the edges.
-
-        Args:
-            margin (int): Margin from the screen edges, where the point won't be generated. 
-                        If margin is less than 0 or greater than half the screen resolution, returns (0, 0).
-
-        Returns:
-            tuple[int, int]: A tuple representing a random point (x, y) on the screen within the screen 
-            resolution minus the margin.
-        """
-        if margin < 0 or margin > bf.const.RESOLUTION[0]//2 or margin > bf.const.RESOLUTION[1]//2:
-            return 0, 0
-        return random.randint(margin, bf.const.RESOLUTION[0] - margin), random.randint(margin, bf.const.RESOLUTION[1] - margin)
+    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)  
+              
 
     @staticmethod
-    def distance_point(a:tuple[float,float],b:tuple[float,float]):
-        return math.sqrt((a[0]-b[0]) ** 2 + (a[1]-b[1])**2)
+    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)]
 
     @staticmethod
-    def rotate_point(point: Vector2, angle: float, center: Vector2) -> Vector2:
-        """Rotate a point around a center by angle (in degrees)."""
-        rad = math.radians(angle)
-        translated = point - center
-        rotated = Vector2(
-            translated.x * math.cos(rad) - translated.y * math.sin(rad),
-            translated.x * math.sin(rad) + translated.y * math.cos(rad)
-        )
-        return rotated + center
+    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 draw_triangle(surface:pygame.Surface, color, rect:pygame.FRect|pygame.Rect, direction:bf.enums.direction=bf.enums.direction.RIGHT,width:int=0):
-        """
-        Draw a filled triangle inside a rectangle on a Pygame surface, pointing in the specified direction.
-        
-        Args:
-            surface: The Pygame surface to draw on.
-            color: The color of the triangle (e.g., (255, 0, 0) for red).
-            rect: A pygame.Rect object defining the rectangle's position and size.
-            direction: A string ('up', 'down', 'left', 'right') indicating the triangle's orientation.
-        """
-        # Define the three vertices of the triangle based on direction
-        rect = rect.copy()
-        rect.inflate_ip(-1,-1)
-        if direction == direction.UP:
-            points = [
-                (rect.left, rect.bottom),      # Bottom-left corner
-                (rect.right, rect.bottom),     # Bottom-right corner
-                (rect.centerx, rect.top)       # Top center (apex)
-            ]
-        elif direction == direction.DOWN:
-            points = [
-                (rect.left, rect.top),         # Top-left corner
-                (rect.right, rect.top),        # Top-right corner
-                (rect.centerx, rect.bottom)    # Bottom center (apex)
-            ]
-        elif direction == direction.LEFT:
-            points = [
-                (rect.right, rect.top),        # Top-right corner
-                (rect.right, rect.bottom),     # Bottom-right corner
-                (rect.left, rect.centery)      # Left center (apex)
-            ]
-        elif direction == direction.RIGHT:
-            points = [
-                (rect.left, rect.top),         # Top-left corner
-                (rect.left, rect.bottom),      # Bottom-left corner
-                (rect.right, rect.centery)     # Right center (apex)
-            ]
+    def load_tileset(path: str, name: str, tilesize):
+        if name in Utils.tilesets:
+            return Utils.tilesets[name]
         else:
-            raise ValueError("Invalid direction")
-
-        # Draw the filled triangle
-        pygame.draw.polygon(surface, color, points,width=width)
-
-    def draw_arc_by_points(surface, color, start_pos, end_pos, tightness=0.5, width=1, resolution=0.5,antialias:bool=False):
-        """
-        Draw a smooth circular arc connecting start_pos and end_pos.
-        `tightness` controls curvature: 0 is straight line, 1 is semicircle, higher = more bulge.
-        Negative tightness flips the bulge direction.
-
-        Args:
-            surface     - pygame Surface
-            color       - RGB or RGBA
-            start_pos   - (x, y)
-            end_pos     - (x, y)
-            tightness   - curvature control, 0 = straight, 1 = half circle
-            width       - line width
-            resolution  - approx pixels per segment
-        Returns:
-            pygame.Rect bounding the drawn arc
-        """
-        p0 = pygame.Vector2(start_pos)
-        p1 = pygame.Vector2(end_pos)
-        chord = p1 - p0
-        if chord.length_squared() == 0:
-            if antialias:
-                return pygame.draw.aacircle(surface, color, p0, width // 2)
-            return pygame.draw.circle(surface, color, p0, width // 2)
+            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
 
-        # Midpoint and perpendicular
-        mid = (p0 + p1) * 0.5
-        perp = pygame.Vector2(-chord.y, chord.x).normalize()
-
-        # Distance of center from midpoint, based on tightness
-        h = chord.length() * tightness
-        center = mid + perp * h
+    @staticmethod
+    def get_tileset(name: str) -> Tileset:
+        if name not in Utils.tilesets:
+            return None
+        return Utils.tilesets[name]
 
-        # Radius and angles
-        r = (p0 - center).length()
-        ang0 = math.atan2(p0.y - center.y, p0.x - center.x)
-        ang1 = math.atan2(p1.y - center.y, p1.x - center.x)
 
-        # Normalize sweep direction based on sign of tightness
-        sweep = ang1 - ang0
-        if tightness > 0 and sweep < 0:
-            sweep += 2 * math.pi
-        elif tightness < 0 and sweep > 0:
-            sweep -= 2 * math.pi
+    
 
-        # Number of points
-        arc_len = abs(sweep * r)
-        segs = max(2, int(arc_len / max(resolution, 1)))
 
-        points = []
-        for i in range(segs + 1):
-            t = i / segs
-            a = ang0 + sweep * t
-            points.append((
-                center.x + math.cos(a) * r,
-                center.y + math.sin(a) * r
-            ))
-        if antialias:
-            return pygame.draw.aalines(surface, color, False, points)
-    
-        return pygame.draw.lines(surface, color, False, points, width)
+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.9a11.dist-info → batframework-1.1.0.dist-info}/METADATA

@@ -1,8 +1,7 @@
 Metadata-Version: 2.2
 Name: batframework
-Version: 1.0.9a11
+Version: 1.1.0
 Summary: Pygame framework for making games easier.
-Author-email: Turan Baturay <baturayturan@gmail.com>
 License: MIT License
         
         Copyright (c) [2023] [TURAN BATURAY]
@@ -24,10 +23,6 @@ License: MIT License
         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.
-Project-URL: Homepage, https://github.com/TuranBaturay/batFramework
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
@@ -35,30 +30,37 @@ Requires-Dist: pygame-ce
 
 # batFramework
 
-Welcome to the `batFramework`. This README provides an overview of the game framework.
+batFramework is a Python game framework built using Pygame, designed to simplify game development by providing entities, scenes, a scene manager, and various utilities.
 
-## batFramework
+## Purpose and Overview
+The primary objective of batFramework is to streamline game development. It is mainly designed to program small 2D games
 
-The `batFramework` is a Python game development framework based on pygame, designed to streamline the process of creating 2D games. It provides a set of tools and components to handle scenes, transitions, cutscenes, audio, sprites, and more. The framework is built with flexibility in mind, allowing you to focus on game design while abstracting away low-level details.
+## Installation and Setup
+To install batFramework, you can use pip:
+```pip install batFramework```
 
-### Features
+The only dependency required is pygame-ce.
 
-- Scene management
-- Cutscene support
-- Audio management (music and sound effects with volume control)
-- Entity, sprite, and animated sprite handling
-- Transition effects
-- Utility modules (time management, constants, etc.)
-- No external dependency except for pygame
+## Usage Instructions
+To create a basic app using batFramework, here's an example:
 
-###  Explore batFramework
+```python
+import batFramework as bf
 
-1. Install Python (version 3.11 or higher) and the latest stable version of pygame-ce.
-2. Clone or download this repository.
-4. Explore the framework's modules in the `batFramework` directory and integrate them into your own game project.
+# Initialize the framework
+bf.init(resolution=(1280, 720), window_caption="My Amazing Program")
 
-For more detailed information on how to use the framework, refer to the documentation (if available) or explore the source code in the `batFramework` directory.
+# Create a manager and a scene
+bf.Manager(bf.Scene("main")).run()
+```
+In practice, users can inherit bf.Scene to create their own scenes, adding specific behaviors, entities, etc.
 
+## Features and Functionalities
 
+For more detailed information, please refer to the [documentation](https://batframework.github.io/batDocumentation/).
+
+
+# License
+ MIT License
 
 

batframework-1.1.0.dist-info/RECORD

@@ -0,0 +1,43 @@
+batFramework/__init__.py,sha256=MLVXC2ymkO3k8LdCgB6TbahgJfhxk4GKAbmndmEgZS4,2146
+batFramework/action.py,sha256=Phk6-q2P-XyV2GVlXPpxyje0due4fIrKnhI1_4anfjI,7600
+batFramework/actionContainer.py,sha256=K9dIgG559ckxzRB3t-lpON4dFTcM2mcKZfsf4bhuJ1k,1092
+batFramework/animatedSprite.py,sha256=kJPKrTOfkbQu2uYDziIEop1z6-gjBwZxkC1Rxd_vBwE,3992
+batFramework/audioManager.py,sha256=5UsDPy4zsDO7Va1y1kM4lSpEJXU95o9F01E-Sts3osg,2546
+batFramework/camera.py,sha256=wt4TyWTgQmQElBVeFI7ONzNI75r0FKtB3KmNH00GeFM,4322
+batFramework/constants.py,sha256=FSyEYLxdAb3JaXA11sAwZBfAImedASohpFcd_7qnG0I,2075
+batFramework/cutscene.py,sha256=5aiIQeWGmvHCb-N3vjmwxhE4dCXv3iZRFHiexSNxCXM,3650
+batFramework/cutsceneBlocks.py,sha256=1gmof0jKJ8SqE-RoErm6n1A0JJ4Ang9Q30xEZnW9NaI,5123
+batFramework/debugger.py,sha256=gh5kOUmGr4t-BFXA17tImid4nzxUqrhsUhE_JV9srNg,1671
+batFramework/dynamicEntity.py,sha256=REIqH0jnfX6yUThoQNkQrsG0390TR6C5la1h2MAioYk,665
+batFramework/easing.py,sha256=vGkk7FDPj27X7NCJXALCEyVKDbpXXebWYtMvxkbhOh0,2217
+batFramework/entity.py,sha256=Tw4_PIA_sY8fhbj9TjE6wPcDTrZZX_Tj7l8oKquqe8U,3178
+batFramework/manager.py,sha256=LdiQVyuPQE23jwO4EjR4zqDymxtRmthUJ7VE7RIEDpU,1583
+batFramework/particles.py,sha256=PX8zSqOS1gyDloGAz3fAlrto51lWMUpBXDIM152EYWc,2172
+batFramework/scene.py,sha256=KM1e53ZfPvuJoSGQZaEl_IouWRYCbFq0QOYTuXYCr-E,7324
+batFramework/sceneManager.py,sha256=sFkQbfMuR19M4duvCf0SOxSY7MkMrkmiiKh72-tC1nI,5743
+batFramework/stateMachine.py,sha256=_er9_dcm6MLmlTjXTVm175eqZ9puaKb31PFmNPRhcSU,1338
+batFramework/time.py,sha256=iGV9mxUFrdXsvm4fJ1faX-VYNsOH7DX2N_aXsDRHhmM,2403
+batFramework/transition.py,sha256=wmL1Mgg_xopzeDbEPJyAmllLB2BCRJZtuMOR7Mez480,4873
+batFramework/transitionManager.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+batFramework/triggerZone.py,sha256=ikOOlJT1KIND0MO2xiilCHuKlb1eQhkCMEhZTi1btsI,586
+batFramework/utils.py,sha256=EUB3bMldWTYFVZxcJk5_7XAWcEz080P7PT5ZtkO5TAQ,6164
+batFramework/gui/__init__.py,sha256=azu5HpC8Q9kupythU5GN5blt7K9oH55oXlOeXsIw1Mw,391
+batFramework/gui/button.py,sha256=05RMQ20P5npgU9QmiT8v6abJhnhjqRgYbpZGaQXr6Bg,2703
+batFramework/gui/constraints.py,sha256=pUTNwJqI2Tu57l8ZeQXVXg3b5F5t3aR4Us-CD5qXwnM,7544
+batFramework/gui/container.py,sha256=XAkPZ0BOVXxzxWP5mKDF_MjYPPPAmUBY-J5zIadO0wQ,1480
+batFramework/gui/debugger.py,sha256=JORHcSYQQCZ0tDzjnNQvDSOOjZVwEQLeqlr8e6xk2RI,1379
+batFramework/gui/frame.py,sha256=zjHwbQT1fpRuvNgfBGZhMO_GdMEWqExa5dNlN9kUnUM,514
+batFramework/gui/image.py,sha256=goOcPntsJeTb3LR7avzi4cXfYHwyGb0KXYttbCiE6fA,777
+batFramework/gui/indicator.py,sha256=OgqDFsi2HCfbSzVjHkHO_shmo4q4ro3wfd0LWSLTJeQ,957
+batFramework/gui/interactiveWidget.py,sha256=rRElxI1eFkvOeTfTaA6f8kVTOswOD-DFLAJDUCAI_Yk,641
+batFramework/gui/label.py,sha256=EO1J5zPVe1skHz-KVqXKBZVKug8UVJUCXyHnvdRDuig,3586
+batFramework/gui/layout.py,sha256=HyVhYTy1AQacALg6XMY5aX5lj7WY__HCCh8sTSBXwgI,3210
+batFramework/gui/root.py,sha256=mhlu8ohqq8N-8q__ugv_tGRgPv-1jIHXBFezMFZ4mUM,1763
+batFramework/gui/shape.py,sha256=CYaD0BdCiuGJO_tS2pALfKPlNGaGRNPzvy-Lk08_R8g,2490
+batFramework/gui/toggle.py,sha256=jAeEyQXA893gDBUmjN7aoGgfsVln5RTODpSFB4LxwTY,2020
+batFramework/gui/widget.py,sha256=1PkxThmet8nI5rvSDE6-iPtD_DsZkk-OxriZHbBZaFc,10509
+batframework-1.1.0.dist-info/LICENSE,sha256=A65iXbMDbOxQLDNOODJLqA7o5RxszYlEqIgNSzBQRf4,1073
+batframework-1.1.0.dist-info/METADATA,sha256=rykq5QH77bM0rueFOF2N93HiLgFuZHRPWc_4Nl-YTHs,2515
+batframework-1.1.0.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
+batframework-1.1.0.dist-info/top_level.txt,sha256=vxAKBIk1oparFTxeXGBrgfIO7iq_YR5Fv1JvPVAIwmA,13
+batframework-1.1.0.dist-info/RECORD,,

batFramework/animation.py

@@ -1,77 +0,0 @@
-import pygame
-import batFramework as bf
-from typing import List, Dict, Tuple, Union, Optional, Self
-
-
-def search_index(target: int, lst: List[int]) -> int:
-    cumulative_sum = 0
-    for index, value in enumerate(lst):
-        cumulative_sum += value
-        if cumulative_sum >= target:
-            return index
-    return -1
-
-
-class Animation:
-    def __init__(
-        self,
-        name: str
-    ) -> None:
-        """
-        Class to hold 2D animation data.
-        All frames are expected to have the same size.
-        This class does not do anything on its own, but can be used to easily manage
-        multiple animations using a simple counter.
-        The duration list provides a entry point for tweaking the timings,
-        so image data can be saved (no need for contiguous duplicate frames)
-        """
-        self.name = name
-        self.frames: list[pygame.Surface] = []
-        self.frames_flipX : list[pygame.Surface] = []
-        self.duration_list = []
-        self.duration_list_length = 0 # prevents calling len() each frame
-        self.numFrames : int = 0
-
-    def from_surface(self,surface:pygame.Surface,frame_size : Tuple[int,int])->Self:
-        """
-        Loads frames from a spritesheet containing all animation frames aligned horizontally, left to right
-        Frames are cut and stored in 2 versions, original and flipped on the horizontal axis.
-        Flipping sprites being pretty common, this serves as a builtin cache.
-        """
-        self.frames : List[pygame.Surface] = list(
-            bf.utils.split_surface(surface, frame_size).values()
-        )
-        self.frames_flipX : List[pygame.Surface] = list(
-            bf.utils.split_surface(
-                surface, frame_size,
-                func=lambda s : pygame.transform.flip(s,True,False)
-            ).values()
-        )
-        self.duration_list_length = len(self.frames)
-        self.numFrames = self.duration_list_length
-        if not self.duration_list:
-            self.duration_list = [1]*self.duration_list_length
-        return self
-
-    def __repr__(self):
-        return f"Animation({self.name})"
-
-    def counter_to_frame(self, counter: Union[float, int]) -> int:
-        if not self.frames : 
-            raise ValueError("Animation has no frames")
-        return search_index(
-            int(counter % self.duration_list_length), self.duration_list
-        )
-
-    def get_frame(self, counter: Union[float, int], flip: bool) -> pygame.Surface:
-        i = self.counter_to_frame(counter)
-        return self.frames_flipX[i] if flip else self.frames[i]
-
-    def set_duration_list(self, duration_list: Union[List[int], int]) -> Self:
-        if isinstance(duration_list, int):
-            duration_list = [duration_list] * len(self.frames)
-        if len(duration_list) != self.numFrames:
-            raise ValueError("duration_list should have values for all frames")
-        self.duration_list = duration_list
-        self.duration_list_length = sum(self.duration_list)
-        return self