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

batFramework/utils.py

@@ -3,9 +3,14 @@ from enum import Enum
 import os
 import batFramework as bf
 import json
+from .enums import *
+import re
+from typing import Callable, TYPE_CHECKING, Any
+from functools import cache
+if TYPE_CHECKING:
+    from .object import Object
+    from .entity import Entity
 
-MAX_FONT_SIZE = 100
-MIN_FONT_SIZE = 8
 
 class Singleton(type):
     _instances = {}
@@ -16,169 +21,100 @@ 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)
+    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'
+        """
+        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
 
-    @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
+        return res
 
     @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)
+    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)
 
-    @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)  
-              
+        return filter_function
 
-    @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]
+    @cache
+    def draw_spotlight(inside_color, outside_color, radius, radius_stop=None, dest_surf=None,size=None):
+        """
+        Draws a circle spotlight centered on a surface
+        inner color on the center
+        gradient towards outside color from radius to radius stop
+        surface background is made transparent
+        if des_surf is None:
+            if size is None :  size is radius_stop*radius_stop
+            returns the newly created surface of size 'size' with the spotlight drawn
+
+        """
+        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:
-            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]
+            pygame.draw.circle(dest_surf, inside_color, center, radius)
 
+        return dest_surf
+    
 
+    @staticmethod
+    def animate_move(entity:"Object", start_pos : tuple[float,float], end_pos:tuple[float,float])->Callable[[float],None]:
+        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
+    
+    @staticmethod
+    def animate_alpha(entity:"Entity", start : int, end:int)->Callable[[float],None]:
+        def func(x):
+            entity.set_alpha(int(pygame.math.clamp(start+(end-start)*x,0,255)))
+        return func
     
 
 
-def move_points(delta, *points):
-    res = []
-    for point in points:
-        res.append((point[0] + delta[0], point[1] + delta[1]))
-    return res

batframework-1.0.8a4.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.8a4.dist-info/METADATA

@@ -0,0 +1,55 @@
+Metadata-Version: 2.1
+Name: batframework
+Version: 1.0.8a4
+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.8a4.dist-info/RECORD

@@ -0,0 +1,58 @@
+batFramework/__init__.py,sha256=gQxP43sMutQeN4dnbO6M8uT3ghN87gyNmcmurtSd33A,2172
+batFramework/action.py,sha256=919IVYKviLyVYDtQL7oZvlVuE_aodjJCuwz6fGi5sCk,8420
+batFramework/actionContainer.py,sha256=qy6-YY3iX26KJ8NqFMSYo6JExohD8HFk0sC1qhb7qA8,2602
+batFramework/animatedSprite.py,sha256=QmYfOw9fgcGRrXregOsEJquobhGWeWSY-L7nkzjY83w,4987
+batFramework/audioManager.py,sha256=8tKSf4huZe5tgH98qHlKoFNjXPGDQNJho6PKfSCe7JA,3869
+batFramework/camera.py,sha256=u1EPSitZ9mEEa32yQB7K6ywnWgWCSumbhrc4HRjimEY,9406
+batFramework/constants.py,sha256=5PyZQZ4fCcLA8k_Upby9KGVF-3pnV2ZZ6t26CxiocPM,1102
+batFramework/cutscene.py,sha256=Jh2g-zC3zaUSQoO2uVOsirWkuLAUFugu2T8B_ob9IPQ,4007
+batFramework/cutsceneBlocks.py,sha256=3jtmTpV48NKCu-Qgjg7KN5KnwXn0kycIQ7t7G3RH3VE,4862
+batFramework/dynamicEntity.py,sha256=LR8DeDa2h6jhDTM6yt61C_0AdYEzvq84NlB5a17K4nM,830
+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=du6KwUH_WGgju11-_dQlxkcW16qdsVu8Q8qEwVuztFY,2633
+batFramework/renderGroup.py,sha256=_VDvmP4iB-XarFJo_Uh5YKwWq1cazHmOBmTXZkqKk40,2020
+batFramework/resourceManager.py,sha256=0cOIAFXT7UzzvgHn9QkWcXsTp8H2bIS70NvvgpBL2_4,3554
+batFramework/scene.py,sha256=zUVYDspPUShDAYJBA7eV_qWGVmb1SAKso06vRcIKyI4,12197
+batFramework/sceneManager.py,sha256=ezAVtgc886tb9q2xQwHonRrEAZk8MDWdNFPAFWsFM_o,7086
+batFramework/scrollingSprite.py,sha256=PPEieAaFcOLE_Lm7cnm3xc7XyLKopCPcDbXEfyThO48,4133
+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=bq24XjO2tZUX_i_BOQ-ccnddu7UUEG3-Gnz1P3IHbcU,4411
+batFramework/transition.py,sha256=67K9TrHQnNXfP9CQXnP__fv1Piewcm4p4n1tBi0veuA,6641
+batFramework/triggerZone.py,sha256=ikOOlJT1KIND0MO2xiilCHuKlb1eQhkCMEhZTi1btsI,586
+batFramework/utils.py,sha256=OSVUvpWtS1BjRpJql_pwnlO76WhTLs9d_K6oONepIUI,3758
+batFramework/gui/__init__.py,sha256=17ij7mrCBCoehqCq1PV6MSXPOfMoLPmrV_G8d6ax4Tk,687
+batFramework/gui/button.py,sha256=Ozs6VKHf9FCQXQODDiLQywGN3hwfXtQ6s2I-rzdjnQg,429
+batFramework/gui/clickableWidget.py,sha256=LTTjLUq8WouEMNf8dwHTkKcOVe4Etyw6lOjxEjovtYw,7058
+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=NIacinJkRV6ClqR8TPF39bi1cP4qVeBaOJtVrBqD6hw,5305
+batFramework/gui/label.py,sha256=mlIwhC_006z1jZ8HbBbyMeuNRIxbmGkyQUt2NU4kSB0,10979
+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=K75814ct6AF4LF8cyzmtUmnTmSflJRnHVMGbpUXwmkE,5084
+batFramework/gui/shape.py,sha256=mg-H4bHtnlYnaa4JkOTmX5MNTzwVADmeoSqeMvgenck,9968
+batFramework/gui/slider.py,sha256=GJ5pR0WoObUzfD4j4xak7eLMDtszggZJPCbE7Rf42Co,7670
+batFramework/gui/style.py,sha256=OeLbft0RkIslQ2IcZpBeF6TaQDONIoBcAHj_Bkh9gFw,131
+batFramework/gui/styleManager.py,sha256=rALKJ-AmRbDAiyu8hVAYRAlkQxw677DiPoNKJZ4xtJ4,1245
+batFramework/gui/textInput.py,sha256=orDq1cfBFjHU41UqtzH3unoZiVZYmSr-HQ84u5lwfwE,4633
+batFramework/gui/toggle.py,sha256=gQTA7fScTlScFWOXxoyJT6wcdjig-dRx7OiiPBq7Yyg,3843
+batFramework/gui/widget.py,sha256=nTAp5oPvr6688KXhmSzjHPNocR8rRTYOH6YZ8SIUB3o,12712
+batFramework/gui/constraints/__init__.py,sha256=qqXE8nnSrEvCSeHdqY8UYPZLetqdubFPI7IdZuh35QE,26
+batFramework/gui/constraints/constraints.py,sha256=ku1vJ4MbnP5KzWrowRM4ydJCs4dJpUVL_iJKKiJna7I,24616
+batframework-1.0.8a4.dist-info/LICENCE,sha256=A65iXbMDbOxQLDNOODJLqA7o5RxszYlEqIgNSzBQRf4,1073
+batframework-1.0.8a4.dist-info/METADATA,sha256=WYIlb6kPrHg-06QOFHxrVRBx-qOZoUw8yCXT8rF98XA,2501
+batframework-1.0.8a4.dist-info/WHEEL,sha256=Z4pYXqR_rTB7OWNDYFOm1qRk0RX6GFP2o8LgvP453Hk,91
+batframework-1.0.8a4.dist-info/top_level.txt,sha256=vxAKBIk1oparFTxeXGBrgfIO7iq_YR5Fv1JvPVAIwmA,13
+batframework-1.0.8a4.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