batframework 1.0.0__py3-none-any.whl → 1.0.1__py3-none-any.whl

batFramework/__init__.py

@@ -39,7 +39,7 @@ def init_screen(resolution: tuple[int, int], flags: int = 0, vsync: int = 0):
         const.RESOLUTION,const.FLAGS, vsync=const.VSYNC
     )
     print(
-        f"Window : {resolution[0]}x{resolution[1]}px | flags:{flags.bit_count()}, vsync:{pygame.display.is_vsync()}"
+        f"Window : {resolution[0]}x{resolution[1]} [vsync:{pygame.display.is_vsync()}]"
     )
 
 def init(

batFramework/easing.py

@@ -20,14 +20,14 @@ class EasingAnimation(bf.Timer):
 
     def __init__(
         self,
-        name: str = None,
+        name: str = '',
         easing_function: Easing = Easing.LINEAR,
         duration: int = 100,
         update_callback=None,
         end_callback=None,
         loop: bool = False,
         reusable: bool = False,
-    ):
+    )->None:
         self.easing_function = easing_function
         self.update_callback = update_callback
         self.value = 0.0
@@ -40,8 +40,8 @@ class EasingAnimation(bf.Timer):
         self.value = 0
         super().start()  # self.elapsed_progress set to 0 here
 
-    def update(self) -> bool:
-        if super().update():
+    def update(self,dt) -> bool:
+        if super().update(dt):
             return True  # If timer ended now, end() is called. So don't process value.
         self._process_value()
         # if self.name == 0: print("UPDATING (callback) in easing")
@@ -61,7 +61,7 @@ class EasingAnimation(bf.Timer):
 
     def _process_value(self):
         p0, p1, p2, p3 = self.easing_function.control_points
-        cache_key = (self.elapsed_progress, p0, p1, p2, p3)
+        cache_key = (self.easing_function,self.elapsed_progress, p0, p1, p2, p3)
         if cache_key in EasingAnimation._cache:
             y = EasingAnimation._cache[cache_key]
         else:

batFramework/entity.py

@@ -33,29 +33,9 @@ class Entity:
         self.visible: bool = True
         self.debug_color: tuple = bf.color.DARK_RED
         self.render_order: int = 0
-        self.rotation_origin = (0, 0)
-        self.rotation: float = 0
-        self._rotated_cache = (0,self.surface)
         self.uid: Any = Entity.__instance_count
         Entity.__instance_count += 1
 
-    def set_rotation_origin(self, point: tuple) -> Self:
-        self.rotation_origin = point
-        return self
-
-    def get_rotation_origin(self) -> tuple:
-        return self.rotation_origin
-
-    def rotate(self, value: float) -> Self:
-        self.rotation = value
-        self._rotated_cache = None
-        return self
-
-    def rotate_by(self, value: float) -> Self:
-        self.rotation += value
-        self._rotated_cache = None
-        return self
-
     def set_render_order(self, render_order: int) -> Self:
         self.render_order = render_order
         return self
@@ -175,18 +155,6 @@ class Entity:
         should_not_draw = not self.visible or not self.surface or not camera.intersects(self.rect)
         if should_not_draw:
             return 0
-        if self.rotation == 0:
-            camera.surface.blit(self.surface, camera.transpose(self.rect))
-            return 1
-        if self._rotated_cache is not None:
-            camera.surface.blit(self._rotated_cache[1], camera.transpose(self.rect))
-            return 1
-            
-        rotated = pygame.transform.rotate(self.surface,self.rotation)
-        # if self.convert_alpha : rotated.convert_alpha()
-        new_center = self.rect.move(self.rotation_origin[0],self.rotation_origin[1]).center
-        tmp = rotated.get_rect(center = new_center)
-        camera.surface.blit(rotated, camera.transpose(tmp))
-        self._rotated_cache = (self.rotation,rotated)
+        camera.surface.blit(self.surface, camera.transpose(self.rect))
 
         return 1

batFramework/gui/button.py

@@ -8,16 +8,42 @@ import pygame
 class Button(Label, InteractiveWidget):
     _cache = {}
 
-    def __init__(self, text: str, callback: Callable = None) -> None:
+    def __init__(self, text: str, callback: None| Callable = None) -> None:
         # Label.__init__(self,text)
         self.callback = callback
         self.click_action = bf.Action("click").add_mouse_control(1)
         self.hover_action = bf.Action("hover").add_mouse_control(pygame.MOUSEMOTION)
         self.is_hovered: bool = False
         self.is_clicking: bool = False
+        self.effect_max :float= 20
+        self.effect_speed :float= 1.2
+        self.effect :float = 0
+        self.enabled :bool = True
         super().__init__(text=text)
         self.set_debug_color("cyan")
 
+    def get_surface_filter(self)->pygame.Surface|None:
+        if not self.surface : return None
+        size = self.surface.get_size()
+        surface_filter = Button._cache.get(size, None)
+        if surface_filter is None:
+            surface_filter = pygame.Surface(size).convert_alpha()
+            surface_filter.fill((30, 30, 30, 0))
+            Button._cache[size] = surface_filter
+        return surface_filter
+    def enable(self)->Self:
+        self.enabled = True
+        self.build()
+        return self
+
+    def disable(self)->Self:
+        self.enabled = False
+        self.build()
+        return self
+
+    def is_enabled(self)->bool:
+        return self.enabled
+
     def set_callback(self, callback: Callable) -> Self:
         self.callback = callback
         return self
@@ -31,7 +57,7 @@ class Button(Label, InteractiveWidget):
         self.build()
 
     def to_string_id(self) -> str:
-        return f"Button({self._text})"
+        return f"Button({self._text}){'' if self.enabled else '[disabled]'}"
 
     def click(self) -> None:
         if self.callback is not None and not self.is_clicking:
@@ -39,6 +65,9 @@ class Button(Label, InteractiveWidget):
             self.callback()
             self.is_clicking = False
 
+    def start_effect(self):
+        if self.effect <= 0 : self.effect = self.effect_max
+
     def do_process_actions(self, event):
         self.click_action.process_event(event)
         self.hover_action.process_event(event)
@@ -52,10 +81,11 @@ class Button(Label, InteractiveWidget):
         if self.click_action.is_active():
             root = self.get_root()
             if root is None : return res
-            if root.get_hovered() == self:
+            if root.get_hovered() == self and self.enabled:
                 if not self.is_focused:
                     self.get_focus()
-                self.click()
+                # self.click()
+                self.start_effect()
                 res = True
         elif self.hover_action.is_active():
             root = self.get_root()
@@ -70,15 +100,38 @@ class Button(Label, InteractiveWidget):
                     res = True
         return res
 
+    def update(self,dt):
+        super().update(dt)
+        if self.effect > 0:
+            self.effect -= dt*60*self.effect_speed
+            self.build()
+            if self.effect <= 0:
+                self.is_hovered = False
+                self.effect = 0
+                self.click()
+                self.build()
+
+    def _build_effect(self)->None:
+        pygame.draw.rect(
+            self.surface,
+            bf.color.CLOUD_WHITE,
+            (0,0,*self.surface.get_size()),
+            int(self.effect),
+            *self._border_radius
+            )
+                
     def build(self) -> None:
         super().build()
+        size = self.surface.get_size()
+        if not self.enabled:
+            self.surface.blit(self.get_surface_filter(), (0, 0), special_flags=pygame.BLEND_SUB)
+            return
+        if self.effect:
+            if self.effect >= 1 : 
+                self._build_effect()
+            return
         if self.is_hovered:
-            hover_surf = Button._cache.get(self.surface.get_size(), None)
-            if hover_surf is None:
-                hover_surf = pygame.Surface(self.surface.get_size()).convert_alpha()
-                hover_surf.fill((30, 30, 30, 0))
-                Button._cache[self.surface.get_size()] = hover_surf
-            self.surface.blit(hover_surf, (0, 0), special_flags=pygame.BLEND_ADD)
+            self.surface.blit(self.get_surface_filter(), (0, 0), special_flags=pygame.BLEND_ADD)
 
     def apply_contraints(self) -> None:
         super().apply_constraints()

batFramework/gui/constraints.py

@@ -137,11 +137,12 @@ class ConstraintPercentageHeight(Constraint):
 
 
 class ConstraintHeight(Constraint):
-    def __init__(self, height: float):
+    def __init__(self, height: float, keep_autoresize: bool = True):
         if height < 0:
             raise ValueError("height can't be negative")
         super().__init__(name="height")
         self.height = height
+        self.keep_autoresize:bool = keep_autoresize
 
     def to_string(self) -> str:
         return f"{super().to_string()}.(height={self.height})"
@@ -151,15 +152,23 @@ class ConstraintHeight(Constraint):
 
     def apply_constraint(self, parent_widget, child_widget):
         if not self.evaluate(parent_widget, child_widget):
+            if child_widget.autoresize:
+                if self.keep_autoresize:
+                    print(
+                        f"Warning: Constraint on {child_widget.to_string()} can't resize, autoresize set to True"
+                    )
+                    return
+                child_widget.set_autoresize(False)
             child_widget.set_size(child_widget.rect.w, self.height)
 
 
 class ConstraintWidth(Constraint):
-    def __init__(self, width: float):
+    def __init__(self, width: float, keep_autoresize: bool = True):
         if width < 0:
             raise ValueError("width can't be negative")
         super().__init__(name="width")
         self.width = width
+        self.keep_autoresize : bool = keep_autoresize
 
     def to_string(self) -> str:
         return f"{super().to_string()}.(width={self.width})"
@@ -169,6 +178,13 @@ class ConstraintWidth(Constraint):
 
     def apply_constraint(self, parent_widget, child_widget):
         if not self.evaluate(parent_widget, child_widget):
+            if child_widget.autoresize:
+                if self.keep_autoresize:
+                    print(
+                        f"Warning: Constraint on {child_widget.to_string()} can't resize, autoresize set to True"
+                    )
+                    return
+                child_widget.set_autoresize(False)
             child_widget.set_size(self.width, child_widget.rect.h)
 
 

batFramework/gui/container.py

@@ -15,6 +15,9 @@ class Container(Widget):
         for child in children:
             self.add_child(child)
 
+    def set_padding(self,value)->Self:
+        return self
+
     def set_layout(self, layout: Layout) -> Self:
         self.layout = layout
         self.apply_constraints()

batFramework/gui/debugger.py

@@ -55,7 +55,7 @@ class Debugger(Label):
     def update(self, dt: float) -> None:
         if not self.parent_scene:
             return
-        if self.parent_scene.get_sharedVar("debugging_mode") not in [1,3]:
+        if self.parent_scene.get_sharedVar("debugging_mode") != 1:
             self.set_visible(False)
             return
         self.set_visible(True)

batFramework/gui/frame.py

@@ -4,25 +4,22 @@ import pygame
 
 
 class Frame(Shape):
-    def __init__(self, width: float, height: float):
+    def __init__(self, width: float, height: float,fit_to_children:bool=True):
+        self.fit_to_children = fit_to_children
         super().__init__(width, height)
         self.set_debug_color("magenta")
-
     def to_string_id(self) -> str:
         return "Frame"
 
-    def fit_to_children(self)->None:
+    def _fit_to_children(self)->None:
         # TODO CLEAN THIS UP
         if not self.children: return
-        target_size = self.children[0].rect.unionall(list(c.rect for c in self.children))
-        self.apply_constraints()
-        self.build_all()
-        self.set_size(*self.inflate_rect_by_padding(target_size).size)
-            # *self.inflate_rect_by_padding(self.rect.unionall(list(c.rect for c in self.children))).size
-        for c in self.children:
-            c.set_position(*c.rect.clamp(self.get_content_rect()).topleft)
+        children_rect = self.children[0].rect.unionall(list(c.rect for c in self.children))
+        self.set_size(*self.inflate_rect_by_padding(children_rect).size)
+        self.rect.center = children_rect.center
         self.apply_all_constraints()
-
+        
     def children_modified(self) -> None:
-        self.fit_to_children()
         super().children_modified()
+        if self.fit_to_children:
+            self._fit_to_children()

batFramework/gui/label.py

@@ -4,13 +4,11 @@ from .shape import Shape
 from typing import Self
 from enum import Enum
 
-
 class Align(Enum):
     LEFT = 1
     RIGHT = 2
     CENTER = 3
 
-
 class Label(Shape):
     def __init__(self, text: str) -> None:
         self._text = ""

batFramework/gui/layout.py

@@ -12,7 +12,7 @@ class Layout:
         self.children_rect = pygame.FRect(0, 0, 0, 0)
 
     def set_child_constraints(self, *constraints) -> Self:
-        self.child_constraints = constraints
+        self.child_constraints = list(constraints)
         self.arrange()
         return self
 
@@ -25,7 +25,7 @@ class Layout:
 
 
 class Column(Layout):
-    def __init__(self, gap: int = 0, fit_children: bool = False, center: bool = False):
+    def __init__(self, gap: int = 0, fit_children: bool = True, center: bool = True):
         super().__init__()
         self.gap = gap
         self.fit_children: bool = fit_children
@@ -45,10 +45,10 @@ class Column(Layout):
             parent_width,
             parent_height,
         )
-        if self.center:
-            self.children_rect.center = self.parent.rect.center
         if self.fit_children:
             self.parent.set_size(parent_width,parent_height)
+        if self.center:
+            self.children_rect.center = self.parent.rect.center
 
         current_y = self.children_rect.top
 
@@ -57,11 +57,10 @@ class Column(Layout):
             current_y += child.rect.h + self.gap
             for c in self.child_constraints:
                 child.add_constraints(c)
-                # if not child.has_constraint(c.name):
 
 
 class Row(Layout):
-    def __init__(self, gap: int = 0, fit_children: bool = False, center: bool = False):
+    def __init__(self, gap: int = 0, fit_children: bool = True, center: bool = True):
         super().__init__()
         self.gap = gap
         self.fit_children: bool = fit_children
@@ -72,8 +71,9 @@ class Row(Layout):
             return
 
         len_children = len(self.parent.children)
-        parent_width = sum(c.rect.w for c in self.parent.children)
-        parent_height = max(c.rect.h for c in self.parent.children)
+        parent_width = sum(c.get_min_required_size()[0] for c in self.parent.children)
+        parent_height = max(c.get_min_required_size()[1] for c in self.parent.children)
+
         if self.gap:
             parent_width += (len_children - 1) * self.gap
         self.children_rect.update(
@@ -85,18 +85,12 @@ class Row(Layout):
         if self.center:
             self.children_rect.center = self.parent.get_content_center()
         if self.fit_children:
-            # c = self.parent.get_constraint("width")
-            # if not c or c.width != parent_width:
-            #     self.parent.add_constraints(ConstraintWidth(parent_width))
-            # c = self.parent.get_constraint("height")
-            # if not c or c.height != parent_height:
-            #     self.parent.add_constraints(ConstraintHeight(parent_height))
             self.parent.set_size(parent_width,parent_height)
+            
         current_x = self.children_rect.left
 
         for child in self.parent.children:
             child.set_position(current_x, self.parent.rect.y)
             current_x += child.rect.w + self.gap
             for c in self.child_constraints:
-                if not child.has_constraint(c.name):
-                    child.add_constraints(c)
+                child.add_constraints(c)

batFramework/gui/widget.py

@@ -48,9 +48,6 @@ class Widget(bf.Entity):
             old_raw_size[0] + self.padding[0] + self.padding[2],
             old_raw_size[1] + self.padding[1] + self.padding[3],
         )
-        if self.parent:
-            self.apply_constraints()
-            self.parent.children_modified()
         return self
 
 
@@ -340,3 +337,5 @@ class Widget(bf.Entity):
     def children_modified(self) -> None:
         if self.parent and not self.is_root:
             self.parent.children_modified()
+
+

batFramework/manager.py

@@ -10,25 +10,28 @@ class Manager(bf.SceneManager):
         self._timeManager = bf.TimeManager()
         self._cutsceneManager = bf.CutsceneManager(self)
         self._clock: pygame.Clock = pygame.Clock()
+        self.do_pre_init()
         super().__init__(*initial_scene_list)
         self.set_sharedVar("clock", self._clock)
         self.do_init()
 
     @staticmethod
-    def set_icon(path: str):
-        surf = pygame.image.load(bf.utils.get_path(path)).convert_alpha()
+    def set_icon(path: str)->None:
+        surf = pygame.image.load(bf.ResourceManager().get_path(path)).convert_alpha()
         pygame.display.set_icon(surf)
 
-    def get_fps(self):
+    def get_fps(self)->float:
         return self._clock.get_fps()
 
-    def do_init(self):
+    def do_init(self)->None:
         pass
 
+    def do_pre_init(self)->None:
+        pass
     def stop(self) -> None:
         self._running = False
 
-    def run(self):
+    def run(self)->None:
         self._running = True
         dt: float = 0
         while self._running:
@@ -40,10 +43,11 @@ class Manager(bf.SceneManager):
                     bf.const.set_resolution((event.w, event.h))
                 self.process_event(event)
             # update
-            dt = self._clock.tick(bf.const.FPS if not bf.const.VSYNC else 0) / 1000
+            # dt = self._clock.tick(bf.const.FPS if not bf.const.VSYNC else 0) / 1000
+            dt = self._clock.tick(0 if  bf.const.VSYNC else bf.const.FPS) / 1000
             # dt = min(dt, 0.02) dirty fix for dt being too high when window not focused for a long time
             self._cutsceneManager.update(dt)
-            self._timeManager.update()
+            self._timeManager.update(dt)
             self.update(dt)
             # render
             self.draw(self._screen)

batFramework/scene.py

@@ -7,16 +7,6 @@ if TYPE_CHECKING:
     from .sceneManager import SceneManager
 import pygame
 import batFramework as bf
-import math
-
-
-def rotate_point(origin, point, angle):
-    ox, oy = origin
-    px, py = point
-    angle_rad = math.radians(angle)
-    qx = ox + math.cos(angle_rad) * (px - ox) - math.sin(angle_rad) * (py - oy)
-    qy = oy + math.sin(angle_rad) * (px - ox) + math.cos(angle_rad) * (py - oy)
-    return int(qx), int(qy)
 
 
 class Scene:

batFramework/sceneManager.py

@@ -73,15 +73,15 @@ class SceneManager:
         self.set_scene(dest_scene_name)
 
     def set_scene(self, name, index=0):
+        target_scene = self.get_scene(name)
         if (
             len(self._scenes) == 0
-            or not self.has_scene(name)
+            or not target_scene
             or index >= len(self._scenes)
+            or index < 0
         ):
             return
 
-        target_scene = self.get_scene(name)
-        if not target_scene : return
         old_scene = self._scenes[index]
         # switch
         old_scene.on_exit()
@@ -99,7 +99,6 @@ class SceneManager:
         ):
             self._debugging = (self._debugging + 1) % 4
             self.set_sharedVar("debugging_mode",self._debugging)
-
             return
         if (
             keys[pygame.K_LCTRL]

batFramework/time.py

@@ -1,90 +1,85 @@
 import pygame
 import batFramework as bf
-
+from typing import Self
 
 class Timer:
-    _highest_count = 0
-
-    def __init__(
-        self,
-        name=None,
-        duration=1000,
-        loop=False,
-        end_callback=None,
-        reusable: bool = False,
-    ):
-        # Initialize timer properties
-        self.start_time = None
-        self.stopped = True
-        self.name = name if name is not None else self._highest_count
-        Timer._highest_count += 1
-        self.duration = duration
-        self.loop = loop
-        self.elapsed_progress = 0.0
+    _count :int = 0
+    def __init__(self,duration:int,end_callback,loop:bool=False)->None:
+        self.name = Timer._count
+        Timer._count+=1
         self.end_callback = end_callback
-        self.reusable: bool = reusable
+        self.duration : int = duration
+        self.paused : bool = False
+        self.elapsed_time : int = -1
+        self.over : bool = False  
+        self.do_delete:bool = False
+        self.is_looping :bool = loop 
 
-    def start(self):
-        # Start the timer and set the start time
-        if self.start_time is None:
-            Time().add_timer(self)
-
-        self.start_time = pygame.time.get_ticks()
-        self.stopped = False
-        self.elapsed_progress = 0.0
-
-    def update(self):
-        if self.stopped:
-            return False
-        current_time = pygame.time.get_ticks()
-        if self.elapsed_progress < 1:
-            # Calculate elapsed progress
-            self.elapsed_progress = (current_time - self.start_time) / self.duration
-            if self.elapsed_progress >= 1:
-                # Timer has completed
-                self.end()
-                return True
-        elif self.loop:
-            # If looping, restart the timer
-            self.start()
-        return False
-
-    def stop(self):
-        # Stop the timer
-        self.stopped = True
+    def stop(self)->Self:
+        self.elapsed_time =-1
+        self.over = False
+        self.paused = False
+        return self
+    
+    def start(self)->Self:
+        if self.elapsed_time >= 0 : return self
+        self.elapsed_time = 0
+        self.paused = False
+        self.over = False
+        bf.TimeManager().add_timer(self)
+        return self
+        
+    def pause(self)->Self:
+        self.paused = True
+        return self
 
+    def resume(self)->Self:
+        self.paused = False
+        return self
+    def delete(self)->Self:
+        self.do_delete = True
+        return self
+    def get_progression(self)->float:
+        if self.elapsed_time < 0 : return 0
+        if self.elapsed_time >= self.duration: return 1
+        return  self.elapsed_time / self.duration
+        
+    def update(self,dt)->None:
+        if self.elapsed_time < 0 or self.paused: return
+        self.elapsed_time += dt
+        # print("update :",self.elapsed_time,self.duration)
+        if self.get_progression() == 1:
+            self.end()
+            
     def end(self):
-        self.elapsed_progress = 1
-        self.stopped = False
-        if self.end_callback:
-            self.end_callback()
+        print("END")
+        self.end_callback()
+        if self.is_looping:
+            self.elapsed_time = -1
+            self.start()
+            return
+            
+        self.over = True
 
-    def ended(self):
-        if self.start_time is None:
-            return False
-        return (
-            (not self.loop)
-            and (self.elapsed_progress >= 1)
-            and (not self.stopped)
-            and not self.reusable
-        )
+    def has_ended(self)->bool:
+        return self.over or self.do_delete
 
 
 class TimeManager(metaclass=bf.Singleton):
     def __init__(self):
-        # Initialize the Time class with a dictionary of timers
+        # Initialize the TimeManager class with a dictionary of timers
         self.timers = {}
 
     def add_timer(self, timer):
         # Add a timer to the dictionary
         self.timers[timer.name] = timer
 
-    def update(self):
+    def update(self,dt):
         # Update all timers and remove completed ones
         for timer in list(self.timers.values()):
-            timer.update()
+            timer.update(dt)
 
-        to_remove = [name for name, timer in self.timers.items() if timer.ended()]
+        to_remove = [name for name, timer in self.timers.items() if timer.has_ended()]
 
         for name in to_remove:
             # print(self.timers.pop(name).name,"removed !")

{batframework-1.0.0.dist-info → batframework-1.0.1.dist-info}/METADATA

@@ -1,13 +1,13 @@
 Metadata-Version: 2.1
 Name: batframework
-Version: 1.0.0
+Version: 1.0.1
 Summary: Pygame framework for making games easier.
 Author-email: Turan Baturay <baturayturan@gmail.com>
 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.10
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENCE
 Requires-Dist: pygame-ce

{batframework-1.0.0.dist-info → batframework-1.0.1.dist-info}/RECORD

@@ -1,4 +1,4 @@
-batFramework/__init__.py,sha256=fCNzIXOvh93YkxmgnGj8MooI8--wMB5VEgd_lfU23MI,2176
+batFramework/__init__.py,sha256=_lW-sW7cIGz_QK96RK8852RCLQZHwgjV2BQwQCHEmwE,2147
 batFramework/action.py,sha256=6XQ3sBylO00UYrGfh5GKjwP9PqgtixIV0um4uwiFj4w,8364
 batFramework/actionContainer.py,sha256=DMWDWZ9mff70VErtunX7yOfiqOxBuGNGfO9b1YXW1CI,2498
 batFramework/animatedSprite.py,sha256=2OrYT4aAyhzWMbQuIej_P74FJ9D7nWSKTkLf6DK3zCs,4184
@@ -8,41 +8,41 @@ batFramework/constants.py,sha256=VbUoeyG00Coz5BxiWrTsO6d0G96Y6Q5CU24E3z5wRR0,142
 batFramework/cutscene.py,sha256=MSKDbP41F7bWMzzNe_U3xWQupvhqPhIiEWFjmh-dwsk,3636
 batFramework/cutsceneBlocks.py,sha256=12i9Ln1y7HK6fv4uBm7ZqjvU76u9E5I-5GCB_mceEO0,5138
 batFramework/dynamicEntity.py,sha256=3-3l58WPO1y6ifncrqkuHOEvNlUaR3YDTYvjTD_2L1I,675
-batFramework/easing.py,sha256=R4WOZTatESaxfqMWbUH1QlXtqTMEGDCBBE-5o8SsxeE,2239
-batFramework/entity.py,sha256=TkFQXnpb4fn7Jrh9lh8GtQRTSDtOk7_YQ_Nn1fsUFWA,5383
+batFramework/easing.py,sha256=M5YjDot_l6DVdotKAbShIQlfotrs_WLpnLqQgQdAfa8,2269
+batFramework/entity.py,sha256=iuWIFoWW5fVByGiY7AUQ-qVymxJLldJMXIKeD4CF4_M,4200
 batFramework/enums.py,sha256=b7d4TuEyG6WGoXn0ABrmc6VsrwKrkJ2bCrMXtz37DB0,226
 batFramework/fontManager.py,sha256=zqevsjZR37EalyHIiaGvnppQfWdCSEWbKLT4da0gYaQ,2136
-batFramework/manager.py,sha256=SfxUE9WWZXK0drVvNZo7_vVrriMgbFlnNsRWeIw6ORQ,1674
+batFramework/manager.py,sha256=vcIpitF4to03NzxXcoWYvWcn5aQG0feC0L0EKamPGfE,1869
 batFramework/particles.py,sha256=pdH9LFfOyDE59DpwHj6KWOj063NfeolzInq2Rj0fctI,2592
 batFramework/resourceManager.py,sha256=Du_MQulBhBJEJ2rFE9YarrKgHjV5DTFSAsc7XofC0Lk,1902
-batFramework/scene.py,sha256=x72LWA6PmjfQS8HtCOFMsFNWMLvKck0xLZOHuwkIssM,10426
-batFramework/sceneManager.py,sha256=ACaixosqLyzozEbjflGXajtEXAJcz7L_MNr30mokoXM,3851
+batFramework/scene.py,sha256=jl41bMYeJ4MgpsSxJ5B7tDTD81KRiwXSUwvbr2ivwyc,10109
+batFramework/sceneManager.py,sha256=Nsz_r3TzCR90DNMhDU_LYrzF3_KsZ9TF6QGJiuVP_UI,3830
 batFramework/sprite.py,sha256=OrWiWN8C7ewQg4Bk5ZN8YR0u-swJXPhlTeQaOgc7eE0,1067
 batFramework/stateMachine.py,sha256=er7WB7I4V81jgUrd-9ftfyYczKpPsEbgdWRXzYl6e9k,1339
 batFramework/tileset.py,sha256=SI2feJV4pnk81ENUJqGsVeD7YheD565UeyVcXQhRq6w,2485
-batFramework/time.py,sha256=K1cA223g0YqoxL-LxqxXZkM88CZRfxw1BIhLLMszlHM,2511
+batFramework/time.py,sha256=bhDJt44IbiAuZyov3Wnj5RFv2xkVVjTuCuE7LyFKoYk,2472
 batFramework/transition.py,sha256=X6pzP2UhDyXQvcsccvnYOuErZdo55P5xNyYYuxZLtvo,4970
 batFramework/transitionManager.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 batFramework/triggerZone.py,sha256=ikOOlJT1KIND0MO2xiilCHuKlb1eQhkCMEhZTi1btsI,586
 batFramework/utils.py,sha256=EVIl1jMKER9L0nR9Nv9MLxeyREUC-JGf7mvmSqYuwCA,1664
 batFramework/gui/__init__.py,sha256=RT9S65ZKtVMsaLYyrqhkWrSaKvNS5PkvQERgtZNA3q4,391
-batFramework/gui/button.py,sha256=If2mJfsncxPn-HAcXVNKKLOOykj6OYQHIo6K1W2DfmI,2802
-batFramework/gui/constraints.py,sha256=hpATPktgxbo6vldTdA0Scc2280gAgIzHOo6s_k55UrQ,9089
-batFramework/gui/container.py,sha256=ozX6B4ykcV1yOP8ECm_bKjksTLFrBMBGwwKpztF64kA,1695
-batFramework/gui/debugger.py,sha256=r42nG-7ZltKZ68cIklG7N6nt1ZiFCopp5EdhiwvzhXQ,3043
-batFramework/gui/frame.py,sha256=3As9cZiyW-VkBzr3SNkPPWj5iQ30m6beVQqbiv38g0k,961
+batFramework/gui/button.py,sha256=p3sfKaPuhve9MYZq7V5ZXQEwfGEPcA0ymbqWnYvdZdM,4389
+batFramework/gui/constraints.py,sha256=XtZIMuauyQ-QOjKGa6JaZfM9qushkcYrG4RKJJVLk8Q,9899
+batFramework/gui/container.py,sha256=qG8Db7H9P4HHRELHtS_bnBTsTh89BWs8PnIqEGBO0D4,1755
+batFramework/gui/debugger.py,sha256=lSfoc5PoxEtz6yQRiEZ7-Y9nd3QQeOcqDdth10voIRs,3035
+batFramework/gui/frame.py,sha256=kY2Jmt1YpYTg4Aa28qmLQaI59BQ-_nq0FOB7Lf2e_hM,861
 batFramework/gui/image.py,sha256=77sISSe6N5bQa3DLLLPfDcz_55xnXsyyTRtqVKIVFnI,1318
 batFramework/gui/indicator.py,sha256=awVhrY1holODuAnChfU1_m6Lp7aLGspSTFdHUnVZo2I,1128
 batFramework/gui/interactiveWidget.py,sha256=jZQspLvlySch5rrZcPi4DsDTpFkDU-qnjqDGy2xX68U,640
-batFramework/gui/label.py,sha256=Q064k9WbVmrCQOkHZWCKXCmFNMLo8V6oa9SBImOtawc,4920
-batFramework/gui/layout.py,sha256=A709ZWZnyMmc9qOI9O__mzFdQ9RjemP-hOLYLPCZpzE,3715
+batFramework/gui/label.py,sha256=q7wNgSSQB7qYVqu7fJNs7x0LoAoc3UhMff__WluwEDs,4918
+batFramework/gui/layout.py,sha256=w1BypRnYzwA4dtcFK4NtUirVnYoBUJsxApliHCXzQmk,3290
 batFramework/gui/root.py,sha256=-NYt8YppPYc359qXieKuw7PiUziLLQbWQH-Y61wtJew,2239
 batFramework/gui/shape.py,sha256=sEuaRjpCRQHj_GomqWtXlHQMyCDw3ZuZsJ6-bAkqJPY,2459
 batFramework/gui/slider.py,sha256=8rLHN-4yxavrOsTQi79SguCAR9Er8qCmkWKjUdMnPYg,62
 batFramework/gui/toggle.py,sha256=dXTIJ8u46xTcEsKchPgvKL9yY7Yxul6mVn3u5yb4pHU,2112
-batFramework/gui/widget.py,sha256=X4g0GP-44xthlTxozvI2G29_7Xs2A9tutCj8Lohng-0,11721
-batframework-1.0.0.dist-info/LICENCE,sha256=A65iXbMDbOxQLDNOODJLqA7o5RxszYlEqIgNSzBQRf4,1073
-batframework-1.0.0.dist-info/METADATA,sha256=qoacoTVficCbd6SUyTRJIpJjpohSlxf5HyjtSueAM18,2499
-batframework-1.0.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-batframework-1.0.0.dist-info/top_level.txt,sha256=vxAKBIk1oparFTxeXGBrgfIO7iq_YR5Fv1JvPVAIwmA,13
-batframework-1.0.0.dist-info/RECORD,,
+batFramework/gui/widget.py,sha256=ZnLdsaQGEN9yCDNTVvWPHsdjgdh-XxivSSvb_VPRpCI,11618
+batframework-1.0.1.dist-info/LICENCE,sha256=A65iXbMDbOxQLDNOODJLqA7o5RxszYlEqIgNSzBQRf4,1073
+batframework-1.0.1.dist-info/METADATA,sha256=BKI9yycx-8xTwNUlx9JBHtbioGJui70x2lCqamiHOKs,2499
+batframework-1.0.1.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+batframework-1.0.1.dist-info/top_level.txt,sha256=vxAKBIk1oparFTxeXGBrgfIO7iq_YR5Fv1JvPVAIwmA,13
+batframework-1.0.1.dist-info/RECORD,,