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

batFramework/transition.py

@@ -10,39 +10,23 @@ Both surfaces to transition need to be the same size
 
 class Transition:
     def __init__(
-        self, duration: float, easing_function: bf.easing = bf.easing.LINEAR
+        self, duration: float=1, easing: 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.controller = bf.EasingController( # main controller for the transition progression
+            duration,easing,
+            update_callback=self.update,end_callback=self.end,
         )
-        self.start_callback : Callable[[],Any] = None
-        self.update_callback : Callable[[float],Any]= None
-        self.end_callback : Callable[[],Any]= None
         self.source: pygame.Surface = None
         self.dest: pygame.Surface = None
+        self.is_over : bool = False # this flag tells the manager the transition is over 
 
     def __repr__(self) -> str:
-        return f"Transition {self.__class__},{self.duration}"
-
-    def set_start_callback(self, func : Callable[[],Any]) -> Self:
-        self.start_callback = func
-        return self
-
-    def set_update_callback(self, func : Callable[[float],Any]) -> Self:
-        self.update_callback = func
-        return self
-
-    def set_end_callback(self, func : Callable[[],Any]) -> Self:
-        self.end_callback = func
-        return self
+        return f"Transition ({self.__class__},{self.duration})"
 
     def set_source(self, surface: pygame.Surface) -> None:
         self.source = surface
@@ -51,127 +35,77 @@ class Transition:
         self.dest = surface
 
     def start(self):
-        if self.controller.has_started():
+        if self.controller.has_started(): # can't start again while it's in progress 
             return
-        if self.duration:
+        if self.duration: # start the transition
             self.controller.start()
-            if self.start_callback:
-                self.start_callback()
             return
 
+        # if no duration the transition is instantaneous
         self.controller.start()
-        if self.start_callback:
-            self.start_callback()
         self.controller.end()
-        self.update(1)
+        self.update(1)# to prevent weird behaviour, update once with progression at max value
         self.end()
 
     def update(self, progression: float) -> None:
-        if self.update_callback:
-            self.update_callback(progression)
+        pass
 
     def end(self):
         self.controller.stop()
-        if self.end_callback:
-            self.end_callback()
+        self.is_over = True
 
     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()
+    def skip(self):
+        self.end()
+
 
 
 class FadeColor(Transition):
-    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,
-    ) -> 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)
+    def __init__(self,duration:float,color=(0,0,0),color_start:float=0.3,color_end:float=0.7, easing = bf.easing.LINEAR):
+        super().__init__(duration, easing)
         self.color = color
-        self.middle_duration = middle_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 transition_to_second(self):
-        self.next_step(self.second.start)
-
-    def transition_to_end(self):
-        self.next_step(self.end)
-
-    def next_step(self, callback : Callable[[],Any]=None) -> None:
-        self.index += 1
-        if callback:
-            callback()
-
-    def set_source(self, surface) -> None:
-        super().set_source(surface)
-        self.first.set_source(surface)
-
-    def set_dest(self, surface) -> None:
-        super().set_dest(surface)
-        self.second.set_dest(surface)
+        self.color_start = color_start
+        self.color_end = color_end
 
     def start(self):
-        if self.start_callback:
-            self.start_callback()
-
+        super().start()
         self.color_surf = pygame.Surface(self.source.get_size())
         self.color_surf.fill(self.color)
 
-        self.first.set_dest(self.color_surf)
-        self.second.set_source(self.color_surf)
-        self.first.start()
-
     def draw(self, surface):
-        if self.index == 0:
-            self.first.draw(surface)
-        elif self.index == 1:
-            surface.blit(self.color_surf, (0, 0))
-        else:
-            self.second.draw(surface)
-
-    def skip(self, no_callback: bool = False):
-        if not no_callback and self.end_callback:
-            self.end_callback()
-
-        self.first.controller.stop()
-        self.timer.stop()
-        self.second.controller.stop()
+        v = self.controller.get_value()
+        if v < self.color_start:
+            v = v/(self.color_start)
+            self.color_surf.set_alpha(255*v)
+            surface.blit(self.source)
+            surface.blit(self.color_surf)
 
+        elif v < self.color_end:
+            self.color_surf.set_alpha(255)
+            surface.blit(self.color_surf)
 
+        else:
+            v = (v-self.color_end)/(1-self.color_end)
+            surface.blit(self.color_surf)
+            self.dest.set_alpha(255*v)
+            surface.blit(self.dest)
 
 class Fade(Transition):
     def end(self):
         self.dest.set_alpha(255)
         return super().end()
 
+    def start(self):
+        super().start()
+
     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()

batFramework/utils.py

@@ -1,5 +1,6 @@
 import pygame
 import batFramework as bf
+import math
 import random
 from .enums import *
 import re
@@ -8,7 +9,7 @@ from functools import cache
 if TYPE_CHECKING:
     from .drawable import Drawable
     from .entity import Entity
-
+from pygame.math import Vector2
 
 
 class Singleton(type):
@@ -150,69 +151,6 @@ class Utils:
         else:
             pygame.draw.circle(dest_surf, inside_color, center, radius)
 
-    @staticmethod
-    def animate_move(entity:"Entity", start_pos : tuple[float,float], end_pos:tuple[float,float])->Callable[[float],None]:
-        """
-        Creates a function to animate the movement of an entity from start_pos to end_pos.
-
-        Args:
-            entity (Entity): The entity to move.
-            start_pos (tuple[float, float]): The starting position of the entity.
-            end_pos (tuple[float, float]): The ending position of the entity.
-
-        Returns:
-            Callable[[float], None]: A function that updates the entity's position based on a progression value (0 to 1).
-        """
-        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: "Entity", end_pos: tuple[float, float]) -> Callable[[float], None]:
-        """
-        Creates a function to animate the movement of an entity to a specified end position, capturing the start position at the start of the animation.
-
-        Args:
-            entity (Entity): The entity to move.
-            end_pos (tuple[float, float]): The target position of the entity.
-
-        Returns:
-            Callable[[float], None]: A function that updates the entity's position based on a progression value (0 to 1).
-        """
-
-        # Start position will be captured once when the animation starts
-        start_pos = [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
-
-            # Set the entity's new position
-            entity.set_center(new_x, new_y)
-
-        return update_position
-
-    @staticmethod
-    def animate_alpha(entity:"Drawable", start : int, end:int)->Callable[[float],None]:
-        """
-        Creates a function to animate the alpha (transparency) of a drawable entity between a start and end value.
-
-        Args:
-            entity (Drawable): The entity to animate.
-            start (int): The starting alpha value (0 to 255).
-            end (int): The ending alpha value (0 to 255).
-
-        Returns:
-            Callable[[float], None]: A function that updates the entity's alpha based on a progression value (0 to 1).
-        """
-        def func(x):
-            entity.set_alpha(int(pygame.math.clamp(start+(end-start)*x,0,255)))
-        return func
-    
-
 
     @staticmethod
     def random_color(min_value: int = 0, max_value: int = 255) -> tuple[int, int, int]:
@@ -236,12 +174,133 @@ class Utils:
 
         Args:
             margin (int): Margin from the screen edges, where the point won't be generated. 
-                        If margin is less than 0 or greater than the screen resolution, returns (0, 0).
+                        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] or margin > bf.const.RESOLUTION[1]:
+        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.0.9a7.dist-info → batframework-1.0.9a9.dist-info}/METADATA

@@ -1,15 +1,36 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: batframework
-Version: 1.0.9a7
+Version: 1.0.9a9
 Summary: Pygame framework for making games easier.
 Author-email: Turan Baturay <baturayturan@gmail.com>
+License: 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.
 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: LICENCE
+License-File: LICENSE
 Requires-Dist: pygame-ce
 
 # batFramework

batframework-1.0.9a9.dist-info/RECORD

@@ -0,0 +1,67 @@
+batFramework/__init__.py,sha256=6-NSXYHNIO713OHgmJmHvry25eLpqwdI0aIG17JtH-k,2961
+batFramework/action.py,sha256=-h8aXHcfPeClJbfz_7tF_zCdDTExCQHye_ev6-Do43s,8397
+batFramework/actionContainer.py,sha256=qy6-YY3iX26KJ8NqFMSYo6JExohD8HFk0sC1qhb7qA8,2602
+batFramework/animatedSprite.py,sha256=NW5fkrooEKytSRxsPruAT3kYY-7cx2whfHAPU-er61Y,1992
+batFramework/animation.py,sha256=kwkfw4Xbh_jkDC-FXUd1lnwNeTQCcA_Eqz3z5OAiakA,3015
+batFramework/audioManager.py,sha256=hloFlneDBZQpk4PLWH3Yn5vk52pC-pEX53_exIhnciY,3941
+batFramework/baseScene.py,sha256=Hxdo6mfjW6c1Ain44XCGWL6yTMpIirHDD0S8SL2NLGY,7092
+batFramework/camera.py,sha256=jukVjwX6GQmv4Odm8beRKIOj0BReVXeYfcsFfsxYAzg,9559
+batFramework/constants.py,sha256=bNVqILsVm2y9hXgzCv8x6HzyntIbipoCadoR0H1EtoU,1543
+batFramework/cutscene.py,sha256=q3HTbHI20MAgt4Qhw_z1pq52KX4FZeKAfqWNtCmzkZM,7473
+batFramework/cutsceneManager.py,sha256=Mb4f7Esx-QAOgS5q1dfFz-xWqsOo6rK7o3MNXiBHbCI,1071
+batFramework/drawable.py,sha256=Mhcj2E3Fibo-9W0jPPDd_JNKZMU3bHNTW9qbTTor30o,2297
+batFramework/dynamicEntity.py,sha256=SjXShy5aT4cQzjlTem05zSQRiNeq52AUXEBVodEG6gI,736
+batFramework/easingController.py,sha256=dql9m5EFHCQ8_u-8iT2XrFn9WHqEsocYll_2mTM6cug,1792
+batFramework/entity.py,sha256=tf6BaLa186jzo1WWqdLtGNnCEK2_ywki7d5qf6B9jN4,3460
+batFramework/enums.py,sha256=kYKnPmJjeuQ2Wwm56bD97HllCtLVBr7vCeskst3zGkY,3137
+batFramework/fontManager.py,sha256=M7h6AVq9Fwr51UTCFoGsg_PSurdjByA4w8qouXq4EKE,2254
+batFramework/manager.py,sha256=-tDp8Vph11W6EKSi7fkZLw40B3uwdPAhepfWG8lIFuI,4427
+batFramework/particle.py,sha256=k-t8H1BwksMUbZ5kDSMMXR5n7ahKEgHMARKgb2pXyr0,3178
+batFramework/propertyEaser.py,sha256=vW9txE-IRE5zplV7KFS7ALnrcb6y9Yn1RLJqAgRLCZQ,2583
+batFramework/renderGroup.py,sha256=e6p76CXVtV4lwJ9OzmLlLIncni8yyUriJeik2bNJNhw,1089
+batFramework/resourceManager.py,sha256=Vb1AxkMybRdSe-IyKS2XqK2MV55pSbJSyXkq-BvMZW8,4588
+batFramework/scene.py,sha256=GjJtIS2daY20EZhjakEeCX7V-riUD9Q_4bl6r4bl_5c,930
+batFramework/sceneLayer.py,sha256=0LJtliyPKn8DSL9mMfS6m5DgXogGPm3yDwXSkBqDTaU,4645
+batFramework/sceneManager.py,sha256=1uND5fFsOr1OzHzRh6li1HLrTZjT4xxi7HJkleOm1A8,6898
+batFramework/scrollingSprite.py,sha256=weIvJkDur71ZJgevvL4aZoQZ9yoDAqBoXX68fawsfbo,4169
+batFramework/sprite.py,sha256=hPE2aMRnW1h5W3RWVVNIHazNRnmtf2_s-dgHpboTW2k,1627
+batFramework/stateMachine.py,sha256=wC-5xbKvf-vGm_N16X9KhgMya5915GyVXL79uk5Bapw,1359
+batFramework/tileset.py,sha256=3AJBWHx90PC43BdLYCBFm811XBrMvWoB-nsUgyo6s-I,1728
+batFramework/timeManager.py,sha256=oWAKWLZZA1be2CwM8qTtOcqnSK3_qLW50tnFLepupRE,6660
+batFramework/transition.py,sha256=kG_6nFmEwCg2ko9--XKor2_hiF9ltwMLr-nPr2QOdyk,5026
+batFramework/triggerZone.py,sha256=MaPp20UoyRHAMiN0_sBanJJ_0cWnYXZEeY-BEaDTDxQ,652
+batFramework/utils.py,sha256=6dDELGW8irN8ZBbY5tMb_-NaBgdnbq-2VkoZjFngnIk,12254
+batFramework/gui/__init__.py,sha256=K_T6t1wZAhd5zeVXwL_ULSwmunSPz533kqMKvg1iPzA,796
+batFramework/gui/animatedLabel.py,sha256=17EunGRfohYI_1cacrXJU3o3IlSSPKkQE9v55U58PYA,3082
+batFramework/gui/button.py,sha256=g4S60hsXpuhZjtrv8C9ht0TEwBHJh-jrsLdxRkSMmbE,552
+batFramework/gui/clickableWidget.py,sha256=vgNpS_NvIF7cyhqeTVs3VYbdz1wj1a22S0-RmOAH8OM,8149
+batFramework/gui/container.py,sha256=WFcJXYdfHHZDLUPA3822zev-mDH8d2fDIoW48HQo1mw,6796
+batFramework/gui/debugger.py,sha256=7SYBZ9KonlbiK2AOvpVelgRS86yxaqfoB1cC9kdmC08,3665
+batFramework/gui/draggableWidget.py,sha256=8gIyIdKTucJmz3MSzfcC_cVBE29anuma5LNfVQrUPy0,1887
+batFramework/gui/image.py,sha256=zzuHGZ7gkTwO7HEzd1jvrG82vV9ami3fgme0sA-8c5I,1755
+batFramework/gui/indicator.py,sha256=uJEqaE93ed13T9C60FW_LTf0aFt9xNbKweAoQD4SYSk,3158
+batFramework/gui/interactiveWidget.py,sha256=UlzRiSp1mW6VmincahCcob1O32LyDZl1H-bw89rW9r8,7786
+batFramework/gui/label.py,sha256=yZGAY-qQijCa9_SxWI_Sfs3mf4xB9ufXQa0nCwuYYPo,11675
+batFramework/gui/layout.py,sha256=0qqEqENSnuXY-3BpdmN5pHkhAN4e3gFsE6WeMkcESTk,17302
+batFramework/gui/meter.py,sha256=OhwEsuJjWW43oMdG-S9HVLReqbE7m1yC6advQVPTVYE,3203
+batFramework/gui/radioButton.py,sha256=TPgYIf75BdKyR4j9mlpJ2OPDabDBCJ1dYAbJBN40PMc,1281
+batFramework/gui/root.py,sha256=RCMya7OM-DU5j9SeDbvU-1JYOeAA2rHdyshBYjw4WvE,7523
+batFramework/gui/selector.py,sha256=1GZMmGWycNERkKX_7r281sQDRncYraFlb7AdcyMWEiY,8240
+batFramework/gui/shape.py,sha256=CdxLt4H71RZ2Q7FSuoNczzsJZvwC_YorhtK70VZcboI,9633
+batFramework/gui/slider.py,sha256=iclIEjHcNQqZ4P8u3_7GIIv4v1YXy6pUt1b65pz2vgI,15063
+batFramework/gui/style.py,sha256=OeLbft0RkIslQ2IcZpBeF6TaQDONIoBcAHj_Bkh9gFw,131
+batFramework/gui/styleManager.py,sha256=mg9VbK0Ux9pwTbq9oICilnQG3xJLnnZEjOzzSg0IVpY,1424
+batFramework/gui/syncedVar.py,sha256=AuDeOLkU3jHzA0t5fD7COETCCBGA3Gm0f1_8tMAyTsc,1577
+batFramework/gui/textInput.py,sha256=RCGKWCRmW-Nl18UUKiNXSaZ_viVrar8vHQ2odhEDOLE,12136
+batFramework/gui/toggle.py,sha256=07WmNIm8I0Ts8PYB4LxTLo7OFM0Xj0K8dkO7gWRfWe8,4616
+batFramework/gui/tooltip.py,sha256=Lay-4I7l6r5efk66j-KNfh4cqHmHF2mY9YtKgPYUiSk,887
+batFramework/gui/widget.py,sha256=KJdjMcveDuFgX9pRLMt5lnl7FPjx-8ni-YfYoqC0QB0,18155
+batFramework/gui/constraints/__init__.py,sha256=qqXE8nnSrEvCSeHdqY8UYPZLetqdubFPI7IdZuh35QE,26
+batFramework/gui/constraints/constraints.py,sha256=LwbaIyerVRo5AJhVgjhcFfxFva6Wm9YcOneC0tONlP4,31598
+batFramework/templates/__init__.py,sha256=E9PmclsTSsTZo-aDrIMiplFJeK4KiUJVFoA9mZw6ur0,25
+batFramework/templates/controller.py,sha256=xylgodtCUj4Tpz6Yze6-uFgarxs44m7HaKY4q6nWqVQ,2969
+batframework-1.0.9a9.dist-info/LICENSE,sha256=A65iXbMDbOxQLDNOODJLqA7o5RxszYlEqIgNSzBQRf4,1073
+batframework-1.0.9a9.dist-info/METADATA,sha256=vdFDSc2TcwiFGX0LLaCHaOYqI7xnNUj3Oi38kWlz3S8,2937
+batframework-1.0.9a9.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
+batframework-1.0.9a9.dist-info/top_level.txt,sha256=vxAKBIk1oparFTxeXGBrgfIO7iq_YR5Fv1JvPVAIwmA,13
+batframework-1.0.9a9.dist-info/RECORD,,

{batframework-1.0.9a7.dist-info → batframework-1.0.9a9.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.6.0)
+Generator: setuptools (76.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

batFramework/character.py

@@ -1,27 +0,0 @@
-import batFramework as bf
-from .stateMachine import State
-from .animatedSprite import AnimatedSprite
-from .dynamicEntity import DynamicEntity
-
-class Character(DynamicEntity,AnimatedSprite):
-    def __init__(self,*args,**kwargs) -> None:
-        super().__init__(*args,**kwargs)
-        self.state_machine = bf.StateMachine(self)
-        self.do_setup_animations()
-        self.do_setup_states()
-
-    def set_state(self,state_name:str):
-        self.state_machine.set_state(state_name)
-
-    def get_current_state(self)->State:
-        return self.state_machine.get_current_state()
-    
-    def update(self, dt: float) -> None:
-        self.state_machine.update(dt)
-        super().update(dt)
-
-    def do_setup_states(self):
-        pass
-    
-    def do_setup_animations(self):
-        pass

batFramework/templates/character.py

@@ -1,43 +0,0 @@
-import batFramework as bf
-import pygame
-from .states import *
-
-class Platform2DCharacter(bf.Character):
-    def __init__(self,*args,**kwargs):
-        super().__init__(*args,**kwargs)
-        self.actions = bf.ActionContainer(
-            *bf.DirectionalKeyControls(),
-            bf.Action("jump").add_key_control(pygame.K_SPACE).set_holding()
-        )
-        self.on_ground : bool = False
-        self.max_jumps = 2
-        self.jump_counter = 0
-        self.jump_force = 150
-        self.speed = 100
-        self.acceleration = 30
-        self.friction = 0.7
-        self.gravity = 300
-        self.terminal_velocity = 1000
-
-    def do_setup_animations(self):
-        self.add_animation(bf.Animation("idle"))
-        self.add_animation(bf.Animation("run"))
-        self.add_animation(bf.Animation("jump"))
-        self.add_animation(bf.Animation("fall"))
-
-
-    def do_setup_states(self):
-        self.state_machine.add_state(Platform2DIdle())
-        self.state_machine.add_state(Platform2DRun())
-        self.state_machine.add_state(Platform2DJump())
-        self.state_machine.add_state(Platform2DFall())
-        self.state_machine.set_state("idle")
-        
-
-
-    def do_reset_actions(self) -> None:
-        self.actions.reset()
-
-    def do_process_actions(self, event: pygame.Event) -> None:
-        self.actions.process_event(event)
-