batframework 1.1.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

batFramework/utils.py

@@ -1,184 +1,306 @@
-import pygame
-from enum import Enum
-import os
-import batFramework as bf
-import json
-
-MAX_FONT_SIZE = 100
-MIN_FONT_SIZE = 8
-
-class Singleton(type):
-    _instances = {}
-
-    def __call__(cls, *args, **kwargs):
-        if cls not in cls._instances:
-            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
-        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 Layout(Enum):
-    FILL = "fill"
-    FIT = "fit"
-
-
-class Utils:
-    pygame.font.init()
-    FONTS = {}
-    tilesets = {}
-
-    @staticmethod
-    def get_path(path: str):
-        return os.path.join(bf.const.RESOURCE_PATH, path)
-
-    @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)
-
-
-    @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)  
-              
-
-    @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)]
-
-    @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 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
+import pygame
+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
+
+
+class Singleton(type):
+    _instances = {}
+
+    def __call__(cls, *args, **kwargs):
+        if cls not in cls._instances:
+            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
+        return cls._instances[cls]
+
+
+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 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.
+
+        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)
+
+                res[(ix, iy)] = sub
+
+        return res
+
+    @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
+
+
+    @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
+
+    @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)
+
+
+    @staticmethod
+    def random_color(min_value: int = 0, max_value: int = 255) -> tuple[int, int, int]:
+        """
+        Generates a random color as an RGB tuple.
+
+        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)
+
+    @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)
+
+    @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 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)
+            ]
+        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)
+
+        # 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
+
+        # 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)

{batframework-1.1.0.dist-info → batframework-2.0.0.dist-info}/LICENSE

@@ -18,4 +18,4 @@ 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.
+SOFTWARE.

{batframework-1.1.0.dist-info → batframework-2.0.0.dist-info}/METADATA

@@ -1,7 +1,8 @@
 Metadata-Version: 2.2
 Name: batframework
-Version: 1.1.0
+Version: 2.0.0
 Summary: Pygame framework for making games easier.
+Author-email: Turan Baturay <baturayturan@gmail.com>
 License: MIT License
         
         Copyright (c) [2023] [TURAN BATURAY]
@@ -23,6 +24,11 @@ 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
@@ -30,7 +36,7 @@ Requires-Dist: pygame-ce
 
 # batFramework
 
-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 is a Python game framework built using Pygame, designed to simplify game development.
 
 ## Purpose and Overview
 The primary objective of batFramework is to streamline game development. It is mainly designed to program small 2D games
@@ -62,5 +68,3 @@ For more detailed information, please refer to the [documentation](https://batfr
 
 # License
  MIT License
-
-

batframework-2.0.0.dist-info/RECORD

@@ -0,0 +1,72 @@
+batFramework/__init__.py,sha256=u5hrbtREsxSIe-zM70KsP5iFGRuX_VP7CWKS6pCRc_o,2995
+batFramework/action.py,sha256=KwnfpYaqKnQWwwIe0YKiC3BLckQcfiQ8cq9AP4jtFqg,8461
+batFramework/actionContainer.py,sha256=mpdjO7wE2ukj5HaALBoBy3xlnocJ9TFBcSVYcF4KAxg,3233
+batFramework/animatedSprite.py,sha256=4pArYyHi387ejpmRwRrKn_hw3k_-u-E4bKlNYJSjsVA,3167
+batFramework/animation.py,sha256=Dtf9SnlgfxECYH4pjTsUjHlFoQM8AckKnPu1_TN8Ff0,3485
+batFramework/audioManager.py,sha256=GcJ8M7SNp_E92liQ4BqL89mZrzI1BN9MYW7UivXRF6U,5895
+batFramework/baseScene.py,sha256=m3M-Pdwq2K41u2h0weLQWc09OL1YjsbkizZg6E9MmLA,7704
+batFramework/camera.py,sha256=7rQ2qLvC_c7SfCr9sxIM3__UTa1RUsO7kCfQYIegTFc,8977
+batFramework/constants.py,sha256=PSsc7xDTlbU8efvM-DODXdmQa20zOSZxAjDZ5-XDTRg,1742
+batFramework/cutscene.py,sha256=eBNAM2KryE7VN3tAZnxTiFhzVsgyQ2q0gCRPmSfzoAE,7176
+batFramework/cutsceneManager.py,sha256=qF79OQGl824dts_JhX_SKG7AFITq4iEyB4HVOpc4B_M,1105
+batFramework/drawable.py,sha256=Rwhy-XWMcYyCA3SSjiwtTtPkb6x3H0GFZWmvjo6-Bmw,3319
+batFramework/dynamicEntity.py,sha256=-Ffo08LNEZn23rdQRDnY0qcUtIqKH92ywwKs8eh6AvE,766
+batFramework/easingController.py,sha256=SMCGo29A0cc25hjvAfwA-fJVDzX6e-MfByhXymloibU,1850
+batFramework/entity.py,sha256=gkxhwMdfUn79AGciM4ikxz8L9qvgflG6o9lUd8UtgHU,3609
+batFramework/enums.py,sha256=II9G7zX7tcPvVHLVoEXNOTzloziHiFaT-ndfs60DwuM,4895
+batFramework/fontManager.py,sha256=6N6TTlaNHGRpZQaiDwZmnv9UM79tmVSKUmNZq-Ka7To,2319
+batFramework/manager.py,sha256=_4f4etdo55p8xNSReIiRX1WcKkm12HRViKHyCnr8bWM,4537
+batFramework/particle.py,sha256=cymuqWBywUNa9i1gEZ8NBTqjB81KVqZUD6Z14lFu7ss,3296
+batFramework/propertyEaser.py,sha256=HcwdXXfAHAO23tKMlEzODqu-ZIuGGVyhO8c01LHO2Lg,2662
+batFramework/renderGroup.py,sha256=Kg8qfMNC1sL1PIiRebPXqeXsyDMNYNIr0Jo1u231aeE,1123
+batFramework/resourceManager.py,sha256=bGWeloXKMuV9JorLY0iLEyICn9ILpgwiw9YRwztx-J0,4718
+batFramework/scene.py,sha256=wBbF0kWHxY4EEV5aCRNT8nliZA19Ea4I6tZJULxR1w0,961
+batFramework/sceneLayer.py,sha256=Jm79d9u0E2RIYRDvLUByCXmjhpO9XHwW6I9BLzv86tI,5114
+batFramework/sceneManager.py,sha256=YeVFzOODbpUvOFZNjQDYpbNjL7NX8UeDh2AezGghX1Y,7226
+batFramework/scrollingSprite.py,sha256=vMg7ULiLDKfk99FAmLGSqH0Z4PJo4oQFFu-dIYWvW8Q,4284
+batFramework/sprite.py,sha256=vwewKu75ibFdSBPc0nQ7CNFvGqRzWG_oqASDcL1iVMM,1426
+batFramework/stateMachine.py,sha256=XkWvR0TX5etTvNi8cIwKQSwgVUBogRBPI0B3-KWw5Do,1329
+batFramework/tileset.py,sha256=zKGeexiqj4sr0JlBwDSrxq2RuO9q-6Q17-rH0p1kM7I,1774
+batFramework/timeManager.py,sha256=pHXJqrmILPTHjyvoBu8wMCNHpKwLXRyYz0CSzxe_NlI,6873
+batFramework/transition.py,sha256=YD2Z3lB0bLmpUb1IoXxVasVBtKbbl-YGpycanJAPLN4,5188
+batFramework/triggerZone.py,sha256=qO4bPGibecerzKQTtLK5FIha44yI00xO027kc2XyrC0,674
+batFramework/utils.py,sha256=iTi_Q-hD4sHU_X4Y0rPtLCfTX7s9BINpQr9hkKBIEMc,12560
+batFramework/gui/__init__.py,sha256=NjoYQJNSgM8i25P3EF1_nQJhua7XTabAAyBvE5i99Ec,959
+batFramework/gui/animatedLabel.py,sha256=j-a3yYJQjPwQt-SsEW8ZS3lPCTOzFZ-1xoUoViWVNLY,3242
+batFramework/gui/button.py,sha256=0v3UawFDlMxH_Lk4JHPcpujrXX2lfT8yxLMffFtEjyM,581
+batFramework/gui/clickableWidget.py,sha256=Kd8E0YL-BQVykCXDqBIhv9moVeMrOJDQAYBYrg2GZVU,8510
+batFramework/gui/collapseContainer.py,sha256=pHJhRytbkIxClv030pw5rk9eymyPvLYFuLOSy2EKzzg,3682
+batFramework/gui/container.py,sha256=9Ms4DxhC2A9PDLvMNNawT91EM_04meguX2q1tO_1K40,7552
+batFramework/gui/debugger.py,sha256=Rw9GqhzKnEQJssu6VxQ24ywdfNw_6ZABkWfD5DsnbVk,3981
+batFramework/gui/draggableWidget.py,sha256=9YXea9rhzzaPhxwXK_-J5POjMp4aOF2fw4n55QwUhaM,2428
+batFramework/gui/image.py,sha256=4wuFSUR21916qPK-zUTjB6u8xQS2QROHADY5lLb2tyg,1889
+batFramework/gui/indicator.py,sha256=n4JcDgKfvj6KGpP1rWajTdKRx37_QAeijKNywplaRo4,3331
+batFramework/gui/interactiveWidget.py,sha256=xZ4-lRPtplS0GpQtV1pnZwzUCrJtKE9WxA04o82u15M,8703
+batFramework/gui/label.py,sha256=8AHHKqireGuD0OmPFQkqAotI-7NvDbeS6Wjd2HifgBg,4789
+batFramework/gui/layout.py,sha256=kYTq4AQYXHzsdHXjOKdigGSiwByjMb4-FcaGv-ny2rY,18778
+batFramework/gui/meter.py,sha256=faJzZ_U-_bb54_7CF8zSNlzZj4fiKMNpEhRzkw7E_cE,5905
+batFramework/gui/radioButton.py,sha256=LEjhU8YVuTGJhaLMJQSyorp-GU6qmLfEUCjhJhTe4zw,1619
+batFramework/gui/root.py,sha256=YPpPEj36Z6OfrY3PdYkXZ7flhkHK6VZiPAGxMddnmvY,7538
+batFramework/gui/scrollingContainer.py,sha256=JiMg9GgXaWt6yIZTs--9hOeI-obQfxzua8CjB7tTMas,9536
+batFramework/gui/selector.py,sha256=sYn9NVb-qmZCW15TsjYcryaarGrRQiPOoAJynMN0xr4,8532
+batFramework/gui/shape.py,sha256=grjH3huNQTamvA2T9vaIZYBqfGRKMRYf1efYUo4K-eo,10305
+batFramework/gui/slider.py,sha256=kctCLYYj2gyrn7ia_f-rY5tlwNU3H5I35cjy0Q62IWw,14116
+batFramework/gui/style.py,sha256=o0o2KrXsqvXFCJbMIra_d9ilvzJDUJsaoF7k9pRCxNo,141
+batFramework/gui/styleManager.py,sha256=bwd7XL4TaILXdmcOTVKuoyKb9MWC15k9iXMRziYxik8,1505
+batFramework/gui/syncedVar.py,sha256=xKctuuVdPcz--yy242W-JHnsLFyyo5k5zWFA2adYdgY,1445
+batFramework/gui/textInput.py,sha256=hLmU2nMQB_tfgnysCxQMLy-3o42UHi9KEv1Qx3fqGeA,13245
+batFramework/gui/textWidget.py,sha256=UYI_UIQFA3ZR95czHR0j-8snE-F_oIbHll2y5pW960s,10131
+batFramework/gui/toggle.py,sha256=OnAPxNhH3mWxmof2hTCCjAA_v4nohZCsJUNqdVu49sc,5244
+batFramework/gui/tooltip.py,sha256=v1i01iisabJaneD0m_W5qYaAuAMUl59yWdOFwuXxaw4,1089
+batFramework/gui/widget.py,sha256=KsVT1-vEWGoGRet6q1eKlVlK-Y8hn-0M8Vdn9gNqCN4,19617
+batFramework/gui/constraints/__init__.py,sha256=ODeCtbhv-TJMuepP9OW46Su_NBOEN6mdmT9tVASuD_0,27
+batFramework/gui/constraints/constraints.py,sha256=c2gDkjfP02EXwyO8JQiSYl64aHPK2wDQtjnea8wFE6s,35745
+batFramework/templates/__init__.py,sha256=0C_SzDmslATebvovJ6geQHjs_4YFRPJOoZb7eiSOrBc,51
+batFramework/templates/character.py,sha256=gOCUV0mx-H3uJvpIkw-6-iuoVM6t5O8zi9GZs_ZmOL0,374
+batFramework/templates/controller.py,sha256=6x2t5fNRIH_m_vcmLi-aNy25toCgSmV8JR9GkzqBWlQ,5305
+batFramework/templates/stateMachine.py,sha256=xod52HElH9VsdqKc-AxR9zUfQyeg-Jtn7JFuBVCFFZM,1370
+batframework-2.0.0.dist-info/LICENSE,sha256=MnykNMKJ2wdYRJaUYtBBZnxkvKXyQLgWy9ouyZBPoY8,1074
+batframework-2.0.0.dist-info/METADATA,sha256=rlm2S86yCDb8jEooGa1cz7Z5qVKgoa2HQdy7Ek__ghE,2719
+batframework-2.0.0.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
+batframework-2.0.0.dist-info/top_level.txt,sha256=vxAKBIk1oparFTxeXGBrgfIO7iq_YR5Fv1JvPVAIwmA,13
+batframework-2.0.0.dist-info/RECORD,,