batframework 1.0.8a2__py3-none-any.whl → 1.0.8a3__py3-none-any.whl

batFramework/utils.py

@@ -3,9 +3,9 @@ from enum import Enum
 import os
 import batFramework as bf
 import json
+from .enums import *
+import re
 
-MAX_FONT_SIZE = 100
-MIN_FONT_SIZE = 8
 
 class Singleton(type):
     _instances = {}
@@ -16,169 +16,44 @@ class Singleton(type):
         return cls._instances[cls]
 
 
-class Direction(Enum):
-    HORIZONTAL = "horizontal"
-    VERTICAL = "vertical"
-
-
-class Alignment(Enum):
-    LEFT = "left"
-    RIGHT = "right"
-    CENTER = "center"
-    TOP = "top"
-    BOTTOM = "bottom"
-
-
-class 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")
+    def split_surface(
+        surface: pygame.Surface, split_size: tuple[int, int], func=None
+    ) -> dict[tuple[int, int], pygame.Surface]:
+        """
+        Splits a surface into subsurfaces and returns a dictionnary of them
+        with their tuple coordinates as keys.
+        Exemple : '(0,0) : Surface'
+        """
+        if surface is None:
             return None
+        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]))
 
-    @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] = {}
+                if func is not None:
+                    sub = func(sub)
 
-        for size in range(MIN_FONT_SIZE, MAX_FONT_SIZE, 2):
-            Utils.FONTS[key][size] = pygame.font.SysFont(font_name,size=size)  
-              
+                res[(ix, iy)] = sub
 
-    @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 filter_text(text_mode: textMode):
+        if text_mode == textMode.ALPHABETICAL:
+            pattern = re.compile(r"[^a-zA-Z]")
+        elif text_mode == textMode.NUMERICAL:
+            pattern = re.compile(r"[^0-9]")
+        elif text_mode == textMode.ALPHANUMERICAL:
+            pattern = re.compile(r"[^a-zA-Z0-9]")
+        else:
+            raise ValueError("Unsupported text mode")
 
+        def filter_function(s: str) -> str:
+            return pattern.sub("", s)
 
-def move_points(delta, *points):
-    res = []
-    for point in points:
-        res.append((point[0] + delta[0], point[1] + delta[1]))
-    return res
+        return filter_function

batframework-1.0.8a3.dist-info/LICENCE

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

batframework-1.0.8a3.dist-info/METADATA

@@ -0,0 +1,55 @@
+Metadata-Version: 2.1
+Name: batframework
+Version: 1.0.8a3
+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.11
+Description-Content-Type: text/markdown
+License-File: LICENCE
+Requires-Dist: pygame-ce
+
+# batFramework & gamejam Project
+
+Welcome to the `batFramework` and the accompanying `gamejam` project. This README provides an overview of both the game framework and the specific game project developed using the framework.
+
+## batFramework
+
+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.
+
+### Features
+
+- 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
+
+###  Explore batFramework
+
+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.
+
+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.
+
+## gamejam Project
+
+The `gamejam` project is a specific game developed using the `batFramework`. It serves as an example of how the framework can be used to create a game from scratch.
+
+### Play the gamejam Project
+
+1. Install Python (version 3.10 or higher) and the latest stable version of pygame-ce.
+2. Clone or download this repository.
+3. Navigate to the `gamejam` directory.
+4. Run the game by executing the main script (e.g., `python main.py`).
+5. Play the game and have fun!
+
+Feel free to explore the code in the `gamejam` directory to see how the `batFramework` is utilized to create the game. You can modify, extend, or use the project as a starting point for your own games.
+
+

batframework-1.0.8a3.dist-info/RECORD

@@ -0,0 +1,58 @@
+batFramework/__init__.py,sha256=5KS96Y0uDx8sue3NyDl2HTFh-CqEZc9otmnUXRCHXws,2189
+batFramework/action.py,sha256=919IVYKviLyVYDtQL7oZvlVuE_aodjJCuwz6fGi5sCk,8420
+batFramework/actionContainer.py,sha256=qy6-YY3iX26KJ8NqFMSYo6JExohD8HFk0sC1qhb7qA8,2602
+batFramework/animatedSprite.py,sha256=1KmhUCX8q2JTyOr0ClLovJ21i6c2SkllTtqygmDSZvo,5168
+batFramework/audioManager.py,sha256=BnfJz5GMMhvyL05mMRM9AyWtyHjyt7lIxScbzY2lmVQ,3873
+batFramework/camera.py,sha256=u1EPSitZ9mEEa32yQB7K6ywnWgWCSumbhrc4HRjimEY,9406
+batFramework/constants.py,sha256=5PyZQZ4fCcLA8k_Upby9KGVF-3pnV2ZZ6t26CxiocPM,1102
+batFramework/cutscene.py,sha256=0gdGJZTslv0d9JcF-brVgjk56jZeDa-ZTgG5DR47y_c,3888
+batFramework/cutsceneBlocks.py,sha256=Uezggx1XgmLvXW1GnuVkGj3tOM8AOxXYx1F9nFGvL-w,4788
+batFramework/dynamicEntity.py,sha256=zp5ShM6fQ-a_hXTHA6UthbInfJl2XazsN6C2hll9nK8,665
+batFramework/easingController.py,sha256=4N8GIp1fsaWBUlDxXx3SMwOq1Mrhn10MZZIO51_CRnk,1677
+batFramework/entity.py,sha256=34gYC6uEMmLkqWtoTG9bgMWRmHRSxhQfxXZKzWS7H2o,2127
+batFramework/enums.py,sha256=Iee21l4BajM7PXXrZF8SWAURX4qwMqKpQ7f12btqIbM,2077
+batFramework/fontManager.py,sha256=VX3HmtyeiOBtv64XZjjJrvk29w6lawHKLfCGBwAa-4g,2242
+batFramework/manager.py,sha256=YRKKv5qWVUs7D8ZqP8ZkfUeTCc3lHxfCfJSYdO5Ep8A,2375
+batFramework/object.py,sha256=SnwnAmfC-7_QTGomQVpBQGSMQjN5NngZoNuvGdqHUrE,3021
+batFramework/particle.py,sha256=yGGKjGtwzL-m48akGNsReLM82IPV1DzrsDy5SN_kMAw,2672
+batFramework/renderGroup.py,sha256=_VDvmP4iB-XarFJo_Uh5YKwWq1cazHmOBmTXZkqKk40,2020
+batFramework/resourceManager.py,sha256=8ysiVDMVRKOGo_kNRH2BiqiUj07kddgi04iNcTt9T-Q,3094
+batFramework/scene.py,sha256=4KHzaIU2fIU2IfXUE8fTX_nlI_iXkylW3B09c3e79KE,11158
+batFramework/sceneManager.py,sha256=BBEd0ngCO42nPxWnBPSTpHmzV4sBTKBrcd4uX7hna98,7151
+batFramework/scrollingSprite.py,sha256=WYVCzuqGTQP7qauT_thzAtghPXnLsZFYNTD0KzYVxp8,4185
+batFramework/sprite.py,sha256=t_kSyUXGOSXQbSBwrKgBUTp5mITeFQbAKNzugjL5SgY,1625
+batFramework/stateMachine.py,sha256=tDQIfQH_4cVZyVNYJ2APe8-yhos3uGk5uSMo_XvktdQ,1335
+batFramework/tileset.py,sha256=3AJBWHx90PC43BdLYCBFm811XBrMvWoB-nsUgyo6s-I,1728
+batFramework/time.py,sha256=IGRIY_g9kpdJxR5wt1lOnLsY9gMReuBJZqnpWRyR-CQ,3963
+batFramework/transition.py,sha256=ioxT5KQQmgSY5yPXDV1CEAj6J_62D6YVU5NUk_Fude0,6442
+batFramework/triggerZone.py,sha256=ikOOlJT1KIND0MO2xiilCHuKlb1eQhkCMEhZTi1btsI,586
+batFramework/utils.py,sha256=esMCG8Yh1MT1V0QsBAPaulCr3pthvxDi2-S_dUJs-3k,1699
+batFramework/gui/__init__.py,sha256=17ij7mrCBCoehqCq1PV6MSXPOfMoLPmrV_G8d6ax4Tk,687
+batFramework/gui/button.py,sha256=Ozs6VKHf9FCQXQODDiLQywGN3hwfXtQ6s2I-rzdjnQg,429
+batFramework/gui/clickableWidget.py,sha256=t7U2m2TSS0cjTjca86xFn0v7C0PtfBV9m8cpecFnRnI,6976
+batFramework/gui/container.py,sha256=wXjuhwCJc71KKSgY2cYgoRscAKB_hIw5N4njJk3Z9lk,5925
+batFramework/gui/debugger.py,sha256=XogxF3J31GO-DZZn6YBrgwpYA5WjadzEfHkQHeMLU7o,3925
+batFramework/gui/dialogueBox.py,sha256=3Z76l9obrpQImI8hjoBS_8G9sY3UILj2d3nJsaxtaI4,3221
+batFramework/gui/draggableWidget.py,sha256=SKG7oMInZ_GTnrbv2T0aqlppuiuLX1tkVSCQJtRMlk8,1392
+batFramework/gui/image.py,sha256=3J1v_YGDPUE_5CwD0ca9PXhHYOdItxUbXakovDjKms4,1750
+batFramework/gui/indicator.py,sha256=leCvxsGxt00-oTn0N5MTmLstLH9uLG3RjQ02KlXtZCQ,1549
+batFramework/gui/interactiveWidget.py,sha256=gcJnMhd4o74oEwZ6AVfxFwLUdNoCaK24ZPFriwh-ld0,5303
+batFramework/gui/label.py,sha256=O48qjfeihyBiGKuHqwQ88ur0YZArXKS4YZHre70o0gg,10636
+batFramework/gui/layout.py,sha256=sslcKULrWKZzaJw_fyb3f9A3PTT3Bm85C8-RbMHeDzo,8377
+batFramework/gui/meter.py,sha256=-5FwPpwWJm3nn8_SoWJNrOqIZ2wiHHTWmpkJyNNaCCY,2282
+batFramework/gui/radioButton.py,sha256=MAlu1_EiPzbvm6TyQ-IITWR6Mv38W2qEOaOKu1MArNQ,2406
+batFramework/gui/root.py,sha256=7yfO4u-21bEL3jiK1ITuTGk8RMFZLZ0vjau0mBuxFfQ,4811
+batFramework/gui/shape.py,sha256=t-DOLYO2V2f85QS0aI6fUZEZKPe1W8J8nvzNoo6Lk-Y,9657
+batFramework/gui/slider.py,sha256=6n4tr3XpF2fGMpxcts16nXq0bxFrBXbjUyKokyrruJw,8587
+batFramework/gui/style.py,sha256=OeLbft0RkIslQ2IcZpBeF6TaQDONIoBcAHj_Bkh9gFw,131
+batFramework/gui/styleManager.py,sha256=rALKJ-AmRbDAiyu8hVAYRAlkQxw677DiPoNKJZ4xtJ4,1245
+batFramework/gui/textInput.py,sha256=Vy-wxED1rk1h_VavCd6lCOpm5aYgFUDfnkv-i4AsHV4,4633
+batFramework/gui/toggle.py,sha256=l-N5koIPp2HYQ0WEGzI2SdZrISe84KhD8MCQIJkZJNA,4410
+batFramework/gui/widget.py,sha256=8zLLoLyyXzb99So-gnl8ovh9ZxVOYgIuAlFvn0JMllE,12608
+batFramework/gui/constraints/__init__.py,sha256=qqXE8nnSrEvCSeHdqY8UYPZLetqdubFPI7IdZuh35QE,26
+batFramework/gui/constraints/constraints.py,sha256=IUcq0jY5--pt9S-GgmXE-79yoPnww3UGjS19iC-8A2U,20004
+batframework-1.0.8a3.dist-info/LICENCE,sha256=A65iXbMDbOxQLDNOODJLqA7o5RxszYlEqIgNSzBQRf4,1073
+batframework-1.0.8a3.dist-info/METADATA,sha256=dFBMbRPDXT-skce0UxDZd-Y2jh-SOsMzzaZorp2Mgbw,2501
+batframework-1.0.8a3.dist-info/WHEEL,sha256=Z4pYXqR_rTB7OWNDYFOm1qRk0RX6GFP2o8LgvP453Hk,91
+batframework-1.0.8a3.dist-info/top_level.txt,sha256=vxAKBIk1oparFTxeXGBrgfIO7iq_YR5Fv1JvPVAIwmA,13
+batframework-1.0.8a3.dist-info/RECORD,,

batFramework/debugger.py

@@ -1,48 +0,0 @@
-import batFramework as bf
-import pygame
-
-
-class Debugger(bf.Label):
-    def __init__(self, manager) -> None:
-        super().__init__()
-        self.manager: bf.Manager = manager
-        self.refresh_rate = 0
-        self._refresh_counter = 0
-        self.dynamic_data = {}
-        self.static_data = {}
-        self.render_order = 99
-        self.set_outline_color((20, 20, 20))
-        # self.set_background_color((0,0,0,0))
-        self.set_text_color("white")
-        # self.set_padding((30,30))
-        self.set_refresh_rate(20)
-        self.add_dynamic_data("FPS", lambda: str(round(self.manager.get_fps())))
-        self.add_dynamic_data("BLITS", lambda: str(self.parent_scene.blit_calls))
-        self.set_visible(False)
-
-    def set_refresh_rate(self, val: int):
-        self.refresh_rate = val
-
-    def update(self, dt: float):
-        visible = self.manager._debugging == 1
-        self.set_visible(visible)
-        if not visible:
-            return
-        self._refresh_counter -= dt * 60
-        if self._refresh_counter < 0:
-            self._refresh_counter = self.refresh_rate
-            self._refresh_debug_info()
-
-    def add_dynamic_data(self, key, func):
-        self.dynamic_data[key] = func
-
-    def set_static_data(self, key, value):
-        self.static_data[key] = value
-
-    def _refresh_debug_info(self):
-        lines = []
-        lines.extend([f"{key}:{value}" for key, value in self.static_data.items()])
-        lines.extend([f"{key}:{func()}" for key, func in self.dynamic_data.items()])
-        debug_text = "\n".join(lines)
-        self.set_text(debug_text)
-        self.update_surface()  # Update the surface after modifying the text

batFramework/easing.py

@@ -1,71 +0,0 @@
-from enum import Enum
-import pygame
-import batFramework as bf
-
-class Easing(Enum):
-    EASE_IN     = (0.12, 0, 0.39, 0)
-    EASE_OUT    = (0.61, 1, 0.88, 1)
-    EASE_IN_OUT = (0.37, 0, 0.63, 1)
-    EASE_IN_OUT_ELASTIC = (.7,-0.5,.3,1.5)
-    LINEAR      = (1, 1, 0, 0)
-    # Add more easing functions as needed
-
-    def __init__(self, *control_points):
-        self.control_points = control_points
-
-class EasingAnimation(bf.Timer):
-    _cache = {}
-    def __init__(
-        self,
-        name:str=None,
-        easing_function:Easing=Easing.LINEAR,
-        duration:int=100,
-        update_callback=None,
-        end_callback=None,
-        loop:bool=False,
-        reusable:bool=False
-    ):
-        self.easing_function = easing_function
-        self.update_callback = update_callback
-        self.value = 0.0
-        super().__init__(name,duration,loop,end_callback,reusable)
-        
-    def get_value(self):
-        return self.value
-
-    def start(self):
-        self.value =  0
-        super().start() # self.elapsed_progress set to 0 here    
-        
-    def update(self)->bool:
-        if super().update():
-            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")
-        if self.update_callback: self.update_callback(self.value)
-        return False
-
-    def end(self):
-        # Call update 1 last time with the last value
-
-        self.elapsed_progress = 1
-        self._process_value()
-        if self.update_callback: self.update_callback(self.value)
-        self.value =  0
-        super().end() # sets elapsed_progress to 0
-
-    def _process_value(self):
-        p0, p1, p2, p3 = self.easing_function.control_points
-        cache_key = (self.elapsed_progress, p0, p1, p2, p3)
-        if cache_key in EasingAnimation._cache:
-            y = EasingAnimation._cache[cache_key]
-        else:
-            t = self.elapsed_progress
-            t_inv = 1.0 - t
-            t2 = t * t
-            t3 = t * t2
-            t_inv2 = t_inv * t_inv
-
-            y = 3 * t_inv2 * t * p1 + 3 * t_inv * t2 * p3 + t3
-            EasingAnimation._cache[cache_key] = y
-        self.value = y

batFramework/gui/constraints.py

@@ -1,204 +0,0 @@
-from .widget import Widget
-import batFramework as bf
-
-
-class Constraint:
-    def __init__(self,name="Constraint", priority=0):
-        self.priority = priority
-        self.name = name
-    def set_priority(self, priority)->"Constraint":
-        self.priority = priority
-        return self
-    def to_string(self)->str:
-        return f"{self.name.upper()}"
-        
-    def evaluate(self, parent_widget:Widget, child_widget:Widget) -> bool:
-        raise NotImplementedError("Subclasses must implement evaluate method")
-
-    def apply(self, parent_widget:Widget, child_widget:Widget=None) -> bool:
-        if not self.evaluate(parent_widget, child_widget):
-            self.apply_constraint(parent_widget, child_widget)
-            return False
-        return True
-        
-    def apply_constraint(self, parent_widget:Widget, child_widget:Widget):
-        raise NotImplementedError("Subclasses must implement apply_constraint method")
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-class ConstraintMinWidth(Constraint):
-    def __init__(self, width):
-        super().__init__(name="min_width")
-        self.min_width = width
-
-    def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.width >= self.min_width
-
-    def apply_constraint(self, parent_widget, child_widget):
-        if not self.evaluate(parent_widget, child_widget):
-            child_widget.set_size(self.min_width,child_widget.rect.h)
-
-
-            
-    
-class ConstraintCenterX(Constraint):
-    def __init__(self):
-        super().__init__(name="centerx")
-
-    def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.centerx == parent_widget.get_content_center()[0]
-
-    def apply_constraint(self,parent_widget,child_widget):
-        if not self.evaluate(parent_widget,child_widget):
-            child_widget.set_center(parent_widget.get_content_center()[0],child_widget.rect.centery)
-
-class ConstraintCenterY(Constraint):
-    def __init__(self):
-        super().__init__(name="centery")
-
-    def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.centery == parent_widget.get_content_center()[1]
-
-    def apply_constraint(self,parent_widget,child_widget):
-        if not self.evaluate(parent_widget,child_widget):
-            child_widget.set_center(child_widget.rect.centerx,parent_widget.get_content_center()[1])
-
-class ConstraintCenter(Constraint):
-    def __init__(self):
-        super().__init__(name="center")
-
-    def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.center == parent_widget.get_content_center()
-
-    def apply_constraint(self,parent_widget,child_widget):
-        if not self.evaluate(parent_widget,child_widget):
-            child_widget.set_center(*parent_widget.get_content_center())
-
-class ConstraintPercentageWidth(Constraint):
-    def __init__(self,percentage:float,keep_autoresize:bool=True):
-        super().__init__(name="percentage_width")
-        self.percentage:float = percentage
-        self.keep_autoresize: bool = keep_autoresize
-    def to_string(self)->str:
-        return f"{super().to_string()}.[{self.percentage},{self.keep_autoresize}]"
-    def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.width == round(parent_widget.get_content_width() * self.percentage)
-
-    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(round(parent_widget.get_content_width() * self.percentage) ,child_widget.rect.h)
-
-
-class ConstraintPercentageHeight(Constraint):
-    def __init__(self,percentage:float,keep_autoresize:bool=True):
-        super().__init__(name="percentage_height")
-        self.percentage:float = percentage
-        self.keep_autoresize: bool = keep_autoresize
-
-    def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.height == round(parent_widget.get_content_height() * self.percentage)
-
-    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,round(parent_widget.get_content_height() * self.percentage))
-
-class ConstraintHeight(Constraint):
-    def __init__(self,height:float):
-        if height < 0 :
-            raise ValueError("height can't be negative")
-        super().__init__(name="height")
-        self.height = height
-
-    def to_string(self)->str:
-        return f"{super().to_string()}.({self.height})"
-
-    def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.height == self.height
-
-    def apply_constraint(self,parent_widget,child_widget):
-        if not self.evaluate(parent_widget,child_widget):
-            child_widget.set_size(child_widget.rect.w,self.height)
-
-class ConstraintWidth(Constraint):
-    def __init__(self,width:float):
-        if width < 0 :
-            raise ValueError("width can't be negative")
-        super().__init__(name="width")
-        self.width = width
-
-    def to_string(self)->str:
-        return f"{super().to_string()}.({self.width})"
-
-    def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.width == self.width
-
-    def apply_constraint(self,parent_widget,child_widget):
-        if not self.evaluate(parent_widget,child_widget):
-            child_widget.set_size(self.width,child_widget.rect.h)
-
-
-class ConstraintAspectRatio(Constraint):
-    def __init__(self,ratio:int|float=1):
-        super().__init__(name="aspect_ratio")
-        if isinstance(ratio, float|int):
-            self.ratio = ratio
-        elif isinstance(ratio,Widget):
-            self.ratio = ratio.rect.w / ratio.rect.h
-        else:
-            raise TypeError(f"Ratio must be float or Widget")
-    def evaluate(self, parent_widget,child_widget):
-        return  self.ratio  ==  child_widget.rect.w / child_widget.rect.h
-        
-    def apply_constraint(self,parent_widget,child_widget):
-        if not self.evaluate(parent_widget,child_widget):
-            return # TODO
-    
-class ConstraintAnchorBottom(Constraint):
-    def __init__(self):
-        super().__init__(name="anchor_bottom")
-        
-    def evaluate(self, parent_widget,child_widget):
-        return  child_widget.rect.bottom == parent_widget.rect.bottom
-        
-    def apply_constraint(self,parent_widget,child_widget):
-        if not self.evaluate(parent_widget,child_widget):
-            child_widget.set_y(parent_widget.get_content_bottom() - child_widget.rect.h)
-
-
-class ConstraintAnchorTopRight(Constraint):
-    def __init__(self):
-        super().__init__(name="anchor_topright")
-        
-    def evaluate(self, parent_widget,child_widget):
-        return  child_widget.rect.topright == parent_widget.rect.topright
-        
-    def apply_constraint(self,parent_widget,child_widget):
-        if not self.evaluate(parent_widget,child_widget):
-            child_widget.set_position(parent_widget.get_content_right()-child_widget.rect.w, parent_widget.get_content_top())
-
-
-
-