batframework 1.0.7__py3-none-any.whl → 1.0.8a2__py3-none-any.whl

batFramework/time.py

@@ -1,85 +1,74 @@
 import pygame
 import batFramework as bf
-from typing import Self
 
 class Timer:
-    _count :int = 0
-    def __init__(self,duration:float|int,end_callback,loop:bool=False)->None:
-        self.name = Timer._count
-        Timer._count+=1
+    _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
         self.end_callback = end_callback
-        self.duration : int|float = 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 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
+        self.reusable:bool = reusable
+    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 pause(self)->Self:
-        self.paused = True
-        return self
+    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 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.end_callback()
-        if self.is_looping:
-            self.elapsed_time = -1
-            self.start()
-            return
-            
-        self.over = True
+        self.elapsed_progress = 1
+        self.stopped = False
+        if self.end_callback:
+            self.end_callback()
 
-    def has_ended(self)->bool:
-        return self.over or self.do_delete
+    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
 
 
-class TimeManager(metaclass=bf.Singleton):
+class Time(metaclass=bf.Singleton):
     def __init__(self):
-        # Initialize the TimeManager class with a dictionary of timers
+        # Initialize the Time 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,dt):
+    def update(self):
         # Update all timers and remove completed ones
-        timers = list(self.timers.values())
-        for timer in [t for t in timers if not t.paused]:
-            timer.update(dt)
+        for timer in list(self.timers.values()):
+            timer.update()
 
-        to_remove = [name for name, timer in self.timers.items() if timer.has_ended()]
+        to_remove = [name for name, timer in self.timers.items() if timer.ended()]
 
         for name in to_remove:
             # print(self.timers.pop(name).name,"removed !")

batFramework/transition.py

@@ -1,3 +1,157 @@
 import pygame
 import batFramework as bf
 
+
+class BaseTransition:
+    def __init__(
+        self,
+        source_surf: pygame.Surface,
+        dest_surf: pygame.Surface,
+        duration=100,
+        **kwargs,
+    ) -> None:
+        self.source = source_surf
+        self.dest = dest_surf
+        self.ended = False
+        self.source_scene_name = ""
+        self.dest_scene_name = ""
+        self.duration = duration
+        self.index = 0
+
+    def set_scene_index(self,index):
+        self.index = index
+
+    def set_source_name(self, name):
+        self.source_scene_name = name
+
+    def set_dest_name(self, name):
+        self.dest_scene_name = name
+
+    def update(self, dt):
+        pass
+
+    def draw(self, surface):
+        pass
+
+    def has_ended(self):
+        return False
+
+    def set_ended(self, val):
+        self.ended = val
+
+
+class FadeColorTransition(BaseTransition):
+    def __init__(
+        self,
+        source_surf,
+        dest_surf,
+        duration=600,
+        color_duration=200,
+        color=bf.color.CLOUD_WHITE,
+        **kwargs,
+    ) -> None:
+        super().__init__(source_surf, dest_surf, duration)
+        self.target_time = duration * 2 + color_duration
+        self.color_surf = pygame.Surface((source_surf.get_rect().size)).convert_alpha()
+        self.color_surf.fill(color)
+        self.ease_out = bf.EasingAnimation(
+            easing_function=bf.Easing.EASE_IN,
+            duration=(duration-color_duration)//2,
+            update_callback = lambda x: self.color_surf.set_alpha(int(255 - (255 * x))),
+            end_callback=lambda: self.set_ended(True))
+
+        self.color_timer = bf.Timer(
+            duration=color_duration,
+            end_callback=lambda: self.set_state("out"))
+        self.ease_in = bf.EasingAnimation(
+            easing_function=bf.Easing.EASE_IN,
+            duration=(duration-color_duration)//2,
+            update_callback=lambda x: self.color_surf.set_alpha(int(255 * x)),
+            # update_callback=lambda x: print(x),
+            end_callback=lambda: self.set_state("color"))
+        self.state = None
+
+        self.state = "in"
+        self.ease_in.start()
+
+    def set_state(self, state: str):
+        self.state = state
+        if state == "in":
+            self.ease_in.start()
+        elif state == "color":
+            self.color_timer.start()
+        elif state == "out":
+            self.ease_out.start()
+
+    def has_ended(self):
+        return self.ended
+
+    def set_ended(self, val):
+        super().set_ended(val)
+
+    def draw(self, surface):
+        if self.state != "color":
+            surface.blit(self.source if self.state == "in" else self.dest, (0, 0))
+        surface.blit(self.color_surf, (0, 0))
+
+
+class FadeTransition(BaseTransition):
+    def __init__(self, source_surf, dest_surf, duration=500) -> None:
+        super().__init__(source_surf, dest_surf)
+        self.anim = bf.EasingAnimation(None,bf.Easing.EASE_IN_OUT,duration,self.update_surface,lambda : self.set_ended(True))
+        self.anim.start()
+
+    def update_surface(self,progress):
+        self.source.set_alpha(int(255 - (255 * progress)))
+        self.dest.set_alpha(int(255 * progress))
+
+    def has_ended(self):
+        return self.ended
+
+    def draw(self, surface):
+        surface.blit(self.source, (0, 0))
+        surface.blit(self.dest, (0, 0))
+
+
+class SlideTransition(BaseTransition):
+    def __init__(
+        self,
+        source_surf,
+        dest_surf,
+        duration=1000,
+        source_alignment: bf.Alignment = bf.Alignment.BOTTOM,
+        easing: bf.Easing = bf.Easing.EASE_IN_OUT,
+        **kwargs,
+    ) -> None:
+        super().__init__(source_surf, dest_surf, duration)
+        self.offset = pygame.Vector2(0, 0)
+        if source_alignment in [bf.Alignment.TOP, bf.Alignment.BOTTOM]:
+            self.offset.y = bf.const.RESOLUTION[1]
+            if source_alignment == bf.Alignment.TOP:
+                self.offset.y *= -1
+        elif source_alignment in [bf.Alignment.LEFT, bf.Alignment.RIGHT]:
+            self.offset.x = bf.const.RESOLUTION[0]
+            if source_alignment == bf.Alignment.LEFT:
+                self.offset.x *= -1
+        else:
+            self.offset.x = -bf.const.RESOLUTION[0]
+            print(
+                f"Unsupported Alignment : {source_alignment.value}, set to default : {bf.Alignment.LEFT.value} "
+            )
+        self.anim = bf.EasingAnimation(
+            easing_function=easing,
+            duration=duration,
+            update_callback =lambda x: self.update_offset(self.offset.lerp((0, 0), x)),
+            end_callback =lambda: self.set_ended(True),
+        )
+        self.anim.start()
+
+    def update_offset(self, vec):
+        self.offset.update(vec)
+
+    def has_ended(self):
+        return self.ended
+
+    def draw(self, surface):
+        surface.blit(self.source, (0, 0))
+        surface.blit(self.dest, self.offset)

batFramework/utils.py

@@ -4,6 +4,9 @@ import os
 import batFramework as bf
 import json
 
+MAX_FONT_SIZE = 100
+MIN_FONT_SIZE = 8
+
 class Singleton(type):
     _instances = {}
 
@@ -13,11 +16,135 @@ 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")
+            return None
+
+    @staticmethod
+    def save_json_to_file(path: str, data) -> bool:
+        try:
+            with open(Utils.get_path(path), "w") as file:
+                json.dump(data, file, indent=2)
+            return True
+        except FileNotFoundError:
+            return False
+            
+    @staticmethod
+    def init_font(raw_path:str):
+            try :
+                if raw_path is not None:
+                    Utils.load_font(raw_path if raw_path else None,None)
+                Utils.load_font(raw_path)
+            except FileNotFoundError:
+                Utils.load_sysfont(raw_path)
+                Utils.load_sysfont(raw_path,None)
+
+
     @staticmethod
-    def img_slice(file, cell_width, cell_height, flipX=False,convert_alpha=True) -> list[pygame.Surface]:
-        src = bf.ResourceManager().get_image(file,convert_alpha=convert_alpha)
-        if src is None : exit(1)
+    def load_font(path:str,name:str=''):
+        if path is not None: path = Utils.get_path(path) # convert path if given
+        filename = os.path.basename(path).split('.')[0] if path is not None else None # get filename if path is given, else None
+        if name != '' : filename = name # if name is not given, name is the filename
+        Utils.FONTS[filename] = {}
+        # fill the dict 
+        for size in range(MIN_FONT_SIZE, MAX_FONT_SIZE, 2):
+            Utils.FONTS[filename][size] = pygame.font.Font(path,size=size)
+
+    def load_sysfont(font_name:str,key:str=''):
+        if key == '' : key = font_name
+        if pygame.font.match_font(font_name) is None: 
+            raise FileNotFoundError(f"Requested font '{font_namey}' was not found")
+        Utils.FONTS[font_name] = {}
+
+        for size in range(MIN_FONT_SIZE, MAX_FONT_SIZE, 2):
+            Utils.FONTS[key][size] = pygame.font.SysFont(font_name,size=size)  
+              
+
+    @staticmethod
+    def get_font(name:str|None=None,text_size:int=12) -> pygame.Font:
+        if not name in Utils.FONTS: return None
+        if not text_size in Utils.FONTS[name]: return None
+        return Utils.FONTS[name][text_size]
+
+    class Tileset:
+        _flip_cache = {}  # {"tileset":tileset,"index","flipX","flipY"}
+
+        def __init__(self, surface: pygame.Surface, tilesize) -> None:
+            self.tile_dict = {}
+            self.surface = surface
+            self.tile_size = tilesize
+            self.split_surface(surface)
+
+        def split_surface(self, surface: pygame.Surface):
+            width, height = surface.get_size()
+            num_tiles_x = width // self.tile_size
+            num_tiles_y = height // self.tile_size
+            # Iterate over the tiles vertically and horizontally
+            for y in range(num_tiles_y):
+                for x in range(num_tiles_x):
+                    # Calculate the coordinates of the current tile in the tileset
+                    tile_x = x * self.tile_size
+                    tile_y = y * self.tile_size
+                    # Create a subsurface for the current tile
+                    tile_surface = surface.subsurface(
+                        pygame.Rect(tile_x, tile_y, self.tile_size, self.tile_size)
+                    )
+                    # Calculate the unique key for the tile (e.g., based on its coordinates)
+                    tile_key = (x, y)
+                    # Store the subsurface in the dictionary with the corresponding key
+                    self.tile_dict[tile_key] = tile_surface
+            # print(self.tile_dict)
+
+        def get_tile(self, x, y, flipX=False, flipY=False) -> pygame.Surface | None:
+            if (x, y) not in self.tile_dict:
+                return None
+            if flipX or flipY:
+                key = f"{x}{y}:{flipX}{flipY}"
+                if not key in self._flip_cache:
+                    self._flip_cache[key] = pygame.transform.flip(
+                        self.tile_dict[(x, y)], flipX, flipY
+                    )
+                return self._flip_cache[key]
+            return self.tile_dict[(x, y)]
+
+    @staticmethod
+    def img_slice(file, cell_width, cell_height, flipX=False) -> list[pygame.Surface]:
+        src = pygame.image.load(
+            os.path.join(bf.const.RESOURCE_PATH, file)
+        ).convert_alpha()
         width, height = src.get_size()
         res = []
         for y in range(0, height, cell_height):
@@ -29,6 +156,26 @@ class Utils:
                 res.append(sub)
         return res
 
+    def load_tileset(path: str, name: str, tilesize):
+        if name in Utils.tilesets:
+            return Utils.tilesets[name]
+        else:
+            img = pygame.image.load(
+                os.path.join(bf.const.RESOURCE_PATH, path)
+            ).convert_alpha()
+            tileset = Utils.Tileset(img, tilesize)
+            Utils.tilesets[name] = tileset
+            return tileset
+
+    @staticmethod
+    def get_tileset(name: str) -> Tileset:
+        if name not in Utils.tilesets:
+            return None
+        return Utils.tilesets[name]
+
+
+    
+
 
 def move_points(delta, *points):
     res = []

batframework-1.0.8a2.dist-info/METADATA

@@ -0,0 +1,58 @@
+Metadata-Version: 2.1
+Name: batframework
+Version: 1.0.8a2
+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
+Description-Content-Type: text/markdown
+Requires-Dist: pygame-ce
+
+# batFramework
+
+batFramework is a Python game framework built using Pygame, designed to simplify game development by providing entities, scenes, a scene manager, and various utilities.
+
+## Purpose and Overview
+The primary objective of batFramework is to streamline game development by utilizing entities and scenes that hold entities. It employs a manager, which inherits from the scene manager, to handle scenes, propagate events, and manage updates and rendering.
+
+## Installation and Setup
+To install batFramework, you can use pip:
+```pip install batFramework```
+
+
+The only dependency required is pygame-ce.
+
+## Usage Instructions
+To create a basic app using batFramework, here's an example:
+
+```python
+import batFramework as bf
+
+# Initialize the framework
+bf.init((1280, 720), window_title="My Amazing Program")
+
+# Create a manager and a scene
+bf.Manager(bf.Scene("main")).run()
+```
+In practice, users can inherit bf.Scene to create their own scenes, adding specific behaviors, entities, etc.
+
+## Features and Functionalities
+
+- Scene management for organizing game components
+- Cutscene support to facilitate storytelling sequences
+- Audio management for music and sound effects with volume control
+- Entity, sprite, and animated sprite support
+- Utility modules such as time management and easingAnimation
+
+Users can leverage these functionalities to build games efficiently using batFramework.
+
+For more detailed usage and examples, please refer to the documentation or codebase.
+
+
+# License
+ MIT License
+
+

batframework-1.0.8a2.dist-info/RECORD

@@ -0,0 +1,42 @@
+batFramework/__init__.py,sha256=MLVXC2ymkO3k8LdCgB6TbahgJfhxk4GKAbmndmEgZS4,2146
+batFramework/action.py,sha256=Phk6-q2P-XyV2GVlXPpxyje0due4fIrKnhI1_4anfjI,7600
+batFramework/actionContainer.py,sha256=K9dIgG559ckxzRB3t-lpON4dFTcM2mcKZfsf4bhuJ1k,1092
+batFramework/animatedSprite.py,sha256=kJPKrTOfkbQu2uYDziIEop1z6-gjBwZxkC1Rxd_vBwE,3992
+batFramework/audioManager.py,sha256=5UsDPy4zsDO7Va1y1kM4lSpEJXU95o9F01E-Sts3osg,2546
+batFramework/camera.py,sha256=wt4TyWTgQmQElBVeFI7ONzNI75r0FKtB3KmNH00GeFM,4322
+batFramework/constants.py,sha256=FSyEYLxdAb3JaXA11sAwZBfAImedASohpFcd_7qnG0I,2075
+batFramework/cutscene.py,sha256=5aiIQeWGmvHCb-N3vjmwxhE4dCXv3iZRFHiexSNxCXM,3650
+batFramework/cutsceneBlocks.py,sha256=1gmof0jKJ8SqE-RoErm6n1A0JJ4Ang9Q30xEZnW9NaI,5123
+batFramework/debugger.py,sha256=gh5kOUmGr4t-BFXA17tImid4nzxUqrhsUhE_JV9srNg,1671
+batFramework/dynamicEntity.py,sha256=REIqH0jnfX6yUThoQNkQrsG0390TR6C5la1h2MAioYk,665
+batFramework/easing.py,sha256=vGkk7FDPj27X7NCJXALCEyVKDbpXXebWYtMvxkbhOh0,2217
+batFramework/entity.py,sha256=Tw4_PIA_sY8fhbj9TjE6wPcDTrZZX_Tj7l8oKquqe8U,3178
+batFramework/manager.py,sha256=LdiQVyuPQE23jwO4EjR4zqDymxtRmthUJ7VE7RIEDpU,1583
+batFramework/particles.py,sha256=PX8zSqOS1gyDloGAz3fAlrto51lWMUpBXDIM152EYWc,2172
+batFramework/scene.py,sha256=KM1e53ZfPvuJoSGQZaEl_IouWRYCbFq0QOYTuXYCr-E,7324
+batFramework/sceneManager.py,sha256=sFkQbfMuR19M4duvCf0SOxSY7MkMrkmiiKh72-tC1nI,5743
+batFramework/stateMachine.py,sha256=_er9_dcm6MLmlTjXTVm175eqZ9puaKb31PFmNPRhcSU,1338
+batFramework/time.py,sha256=iGV9mxUFrdXsvm4fJ1faX-VYNsOH7DX2N_aXsDRHhmM,2403
+batFramework/transition.py,sha256=wmL1Mgg_xopzeDbEPJyAmllLB2BCRJZtuMOR7Mez480,4873
+batFramework/transitionManager.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+batFramework/triggerZone.py,sha256=ikOOlJT1KIND0MO2xiilCHuKlb1eQhkCMEhZTi1btsI,586
+batFramework/utils.py,sha256=EUB3bMldWTYFVZxcJk5_7XAWcEz080P7PT5ZtkO5TAQ,6164
+batFramework/gui/__init__.py,sha256=azu5HpC8Q9kupythU5GN5blt7K9oH55oXlOeXsIw1Mw,391
+batFramework/gui/button.py,sha256=05RMQ20P5npgU9QmiT8v6abJhnhjqRgYbpZGaQXr6Bg,2703
+batFramework/gui/constraints.py,sha256=pUTNwJqI2Tu57l8ZeQXVXg3b5F5t3aR4Us-CD5qXwnM,7544
+batFramework/gui/container.py,sha256=XAkPZ0BOVXxzxWP5mKDF_MjYPPPAmUBY-J5zIadO0wQ,1480
+batFramework/gui/debugger.py,sha256=JORHcSYQQCZ0tDzjnNQvDSOOjZVwEQLeqlr8e6xk2RI,1379
+batFramework/gui/frame.py,sha256=zjHwbQT1fpRuvNgfBGZhMO_GdMEWqExa5dNlN9kUnUM,514
+batFramework/gui/image.py,sha256=goOcPntsJeTb3LR7avzi4cXfYHwyGb0KXYttbCiE6fA,777
+batFramework/gui/indicator.py,sha256=OgqDFsi2HCfbSzVjHkHO_shmo4q4ro3wfd0LWSLTJeQ,957
+batFramework/gui/interactiveWidget.py,sha256=rRElxI1eFkvOeTfTaA6f8kVTOswOD-DFLAJDUCAI_Yk,641
+batFramework/gui/label.py,sha256=EO1J5zPVe1skHz-KVqXKBZVKug8UVJUCXyHnvdRDuig,3586
+batFramework/gui/layout.py,sha256=HyVhYTy1AQacALg6XMY5aX5lj7WY__HCCh8sTSBXwgI,3210
+batFramework/gui/root.py,sha256=mhlu8ohqq8N-8q__ugv_tGRgPv-1jIHXBFezMFZ4mUM,1763
+batFramework/gui/shape.py,sha256=CYaD0BdCiuGJO_tS2pALfKPlNGaGRNPzvy-Lk08_R8g,2490
+batFramework/gui/toggle.py,sha256=jAeEyQXA893gDBUmjN7aoGgfsVln5RTODpSFB4LxwTY,2020
+batFramework/gui/widget.py,sha256=1PkxThmet8nI5rvSDE6-iPtD_DsZkk-OxriZHbBZaFc,10509
+batframework-1.0.8a2.dist-info/METADATA,sha256=YnyIVG7YvAIqBiqWVbeQ6h4tWUT7VHAHUr_Is1uQyJw,1980
+batframework-1.0.8a2.dist-info/WHEEL,sha256=Z4pYXqR_rTB7OWNDYFOm1qRk0RX6GFP2o8LgvP453Hk,91
+batframework-1.0.8a2.dist-info/top_level.txt,sha256=vxAKBIk1oparFTxeXGBrgfIO7iq_YR5Fv1JvPVAIwmA,13
+batframework-1.0.8a2.dist-info/RECORD,,

{batframework-1.0.7.dist-info → batframework-1.0.8a2.dist-info}/WHEEL

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

batFramework/enums.py

@@ -1,14 +0,0 @@
-from enum import Enum
-
-class Direction(Enum):
-    HORIZONTAL = "horizontal"
-    VERTICAL = "vertical"
-
-
-class Alignment(Enum):
-    LEFT = "left"
-    RIGHT = "right"
-    CENTER = "center"
-    TOP = "top"
-    BOTTOM = "bottom"
-

batFramework/fontManager.py

@@ -1,57 +0,0 @@
-from .utils import Singleton
-# put font stuff here later
-import pygame
-import os
-import batFramework as bf
-class FontManager(metaclass=Singleton):
-    def __init__(self):
-        pygame.font.init()
-        self.DEFAULT_TEXT_SIZE = 16
-        self.MIN_FONT_SIZE = 8
-        self.MAX_FONT_SIZE = 64
-        self.DEFAULT_ANTIALIAS = False
-        self.FONTS = {}
-
-    def set_default_text_size(self,size: int):
-        self.DEFAULT_TEXT_SIZE = size
-
-    def init_font(self,raw_path: str|None):
-        try:
-            if raw_path is not None:
-                self.load_font(raw_path if raw_path else None, None)
-            self.load_font(raw_path)
-        except FileNotFoundError:
-            self.load_sysfont(raw_path)
-            self.load_sysfont(raw_path, None)
-
-    def load_font(self,path: str|None, name: str|None = ""):
-        if path is not None:
-            path = bf.ResourceManager().get_path(path)  # convert path if given
-        filename = None
-        if path is not None:
-            filename = os.path.basename(path).split(".")[0]
-        
-          # get filename if path is given, else None
-        if name != "":
-            filename = name  # if name is not given, name is the filename
-        self.FONTS[filename] = {}
-        # fill the dict
-        for size in range(self.MIN_FONT_SIZE, self.MAX_FONT_SIZE, 2):
-            self.FONTS[filename][size] = pygame.font.Font(path, size=size)
-
-    def load_sysfont(self,font_name: str|None, key: str |None= ""):
-        if key == "":
-            key = font_name
-        if font_name is None or pygame.font.match_font(font_name) is None:
-            raise FileNotFoundError(f"Requested font '{font_name}' was not found")
-        self.FONTS[font_name] = {}
-
-        for size in range(self.MIN_FONT_SIZE, self.MAX_FONT_SIZE, 2):
-            self.FONTS[key][size] = pygame.font.SysFont(font_name, size=size)
-
-    def get_font(self,name: str | None = None, text_size: int = 12) -> pygame.Font|None:
-        if not name in self.FONTS:
-            return None
-        if not text_size in self.FONTS[name]:
-            return None
-        return self.FONTS[name][text_size]