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

batFramework/easingController.py

@@ -1,58 +0,0 @@
-import pygame
-import batFramework as bf
-from functools import lru_cache
-from .enums import easing
-
-
-@lru_cache(maxsize=None)
-def process_value(progress: float, p0: float, p1: float, p2: float, p3: float) -> float:
-    if p0 == 0 and p1 == 0 and p2 == 1 and p3 == 1:  # Linear easing control points
-        return progress
-    t = progress
-    t_inv = 1.0 - t
-    t2 = t * t
-    t3 = t * t2
-    t_inv2 = t_inv * t_inv
-    return 3 * t_inv2 * t * p1 + 3 * t_inv * t2 * p3 + t3
-
-
-class EasingController(bf.Timer):
-    def __init__(
-        self,
-        easing_function: easing = easing.LINEAR,
-        duration: float = 1,
-        update_callback=None,
-        end_callback=None,
-        loop: bool = False,
-    ) -> None:
-        self.easing_function = easing_function
-        self.update_callback = update_callback
-        self.value: float = 0.0
-        super().__init__(duration, end_callback, loop)
-
-    def get_value(self) -> float:
-        return self.value
-
-    def start(self, force: bool = False):
-        super().start(force)
-        self.value = 0
-
-    def update(self, dt: float) -> None:
-        if self.get_progression() == 1:
-            return
-        super().update(dt)
-        if self.get_progression() == 0:
-            return
-        if self.easing_function == easing.LINEAR:
-            self.value = self.get_progression()
-        else:
-            self.value = process_value(
-                self.get_progression(), *self.easing_function.control_points
-            )
-        if self.update_callback:
-            self.update_callback(self.value)
-
-    def end(self):
-        if self.update_callback:
-            self.update_callback(1)
-        super().end()

batFramework/enums.py

@@ -1,104 +0,0 @@
-from enum import Enum
-
-
-class color:
-    WHITE = (255, 255, 255)
-    LIGHTER_GRAY = (236, 240, 241)
-    LIGHT_GRAY = (189, 195, 199)
-    DARK_GRAY = (66, 66, 66)
-    DARKER_GRAY = (23, 23, 23)
-    BLACK = (0, 0, 0)
-
-    TURQUOISE = (26, 188, 156)
-    TURQUOISE_SHADE = (22, 160, 133)
-
-    GREEN = (46, 204, 113)
-    GREEN_SHADE = (39, 174, 96)
-
-    BLUE = (52, 152, 219)
-    BLUE_SHADE = (41, 128, 185)
-
-    PURPLE = (155, 89, 182)
-    PURPLE_SHADE = (142, 68, 173)
-
-    CHARCOAL = (52, 73, 94)
-    CHARCOAL_SHADE = (44, 62, 80)
-
-    GOLD = (241, 196, 15)
-    GOLD_SHADE = (243, 156, 18)
-
-    ORANGE = (230, 126, 34)
-    ORANGE_SHADE = (211, 84, 0)
-
-    RED = (231, 76, 60)
-    RED_SHADE = (192, 57, 43)
-
-    CLOUD = (236, 240, 241)
-    CLOUD_SHADE = (189, 195, 199)
-
-    CONCRETE = (149, 165, 166)
-    CONCRETE_SHADE = (127, 140, 141)
-
-    # GB
-    DARKER_GB = (27, 42, 9)
-    DARK_GB = (14, 69, 11)
-    LIGHT_GB = (73, 107, 34)
-    LIGHTER_GB = (154, 158, 63)
-
-class easing(Enum):
-    LINEAR = (0, 0, 1, 1)
-    EASE_IN = (0.95, 0, 1, 0.55)
-    EASE_OUT = (0.5, 1, 0.5, 1)
-    EASE_IN_OUT = (0.55, 0, 0.45, 1)
-    EASE_IN_OUT_ELASTIC = (0.39, -0.55, 0.3, 1.3)
-
-    def __init__(self, *control_points):
-        self.control_points = control_points
-
-class axis(Enum):
-    HORIZONTAL = "horizontal"
-    VERTICAL = "vertical"
-
-class spacing(Enum):
-    MIN = "min"
-    HALF = "half"
-    MAX = "max"
-    MANUAL = "manual"
-class alignment(Enum):
-    LEFT = "left"
-    RIGHT = "right"
-    CENTER = "center"
-    TOP = "top"
-    BOTTOM = "bottom"
-    TOPLEFT = "topleft"
-    TOPRIGHT = "topright"
-    MIDLEFT = "midleft"
-    MIDRIGHT = "midright"
-    BOTTOMLEFT = "bottomleft"
-    BOTTOMRIGHT = "bottomright"
-
-class direction(Enum):
-    LEFT = 0
-    UP = 1
-    RIGHT = 2
-    DOWN = 3 
-
-class drawMode(Enum):
-    SOLID = 0
-    TEXTURED = 1
-
-class debugMode(Enum):
-    HIDDEN = 0
-    DEBUGGER = 1
-    OUTLINES = 2
-
-class actionType(Enum):
-    INSTANTANEOUS = 0
-    CONTINUOUS = 1
-    HOLDING = 2
-
-
-class textMode(Enum):
-    ALPHABETICAL = 0
-    NUMERICAL = 1
-    ALPHANUMERIC = 3 

batFramework/fontManager.py

@@ -1,65 +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_antialias(self,value:bool):
-        self.DEFAULT_ANTIALIAS = value
-
-    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]

batFramework/gui/clickableWidget.py

@@ -1,206 +0,0 @@
-from .label import Label
-import batFramework as bf
-from typing import Self, Callable
-from .interactiveWidget import InteractiveWidget
-from .shape import Shape
-import pygame
-from math import ceil
-
-
-class ClickableWidget(Shape,InteractiveWidget):
-    _cache: dict = {}
-
-    def __init__(self,callback: None | Callable = None,*args,**kwargs) -> None:
-        super().__init__(*args, **kwargs)
-        self.callback = callback
-        self.is_pressed: bool = False
-        self.enabled: bool = True
-        self.hover_cursor = bf.const.DEFAULT_HOVER_CURSOR
-        self.click_cursor = bf.const.DEFAULT_CLICK_CURSOR
-        self.click_down_sound = None
-        self.click_up_sound = None
-        self.get_focus_sound = None
-        self.lose_focus_sound = None
-        self.pressed_relief : int = 1
-        self.unpressed_relief : int = 2
-        self.silent_focus : bool = False
-        self.set_debug_color("cyan")
-        self.set_relief(self.unpressed_relief)
-
-    def set_unpressed_relief(self,relief:int=0)->Self:
-        if relief == self.unpressed_relief : return self
-        self.unpressed_relief = relief 
-        self.dirty_shape = True
-        if not self.is_pressed : self.set_relief(relief)
-        return self
-
-    def set_silent_focus(self,value:bool)->Self:
-        self.silent_focus = value
-        return self
-
-
-    def set_pressed_relief(self,relief:int=0)->Self:
-        if relief == self.pressed_relief : return self
-        self.pressed_relief = relief 
-        self.dirty_shape = True
-        if self.is_pressed : self.set_relief(relief)
-
-        return self
-
-    def set_click_down_sound(self, sound_name: str) -> Self:
-        self.click_down_sound = sound_name
-        return self
-
-    def set_click_up_sound(self, sound_name: str) -> Self:
-        self.click_up_sound = sound_name
-        return self
-
-    def set_get_focus_sound(self, sound_name: str) -> Self:
-        self.get_focus_sound = sound_name
-        return self
-
-    def set_lose_focus_sound(self, sound_name: str) -> Self:
-        self.lose_focus_sound = sound_name
-        return self
-
-    def set_hover_cursor(self, cursor: pygame.Cursor) -> Self:
-        self.hover_cursor = cursor
-        return self
-
-    def set_click_cursor(self, cursor: pygame.Cursor) -> Self:
-        self.click_cursor = cursor
-        return self
-
-    def get_surface_filter(self) -> pygame.Surface | None:
-        size = int(self.rect.w),int(self.rect.h)
-        surface_filter = ClickableWidget._cache.get((size, *self.border_radius), None)
-        if surface_filter is None:
-            # Create a mask from the original surface
-            mask = pygame.mask.from_surface(self.surface, threshold=0)
-            
-            silhouette_surface = mask.to_surface(setcolor=(30, 30, 30), unsetcolor=(0,0,0))
-
-            ClickableWidget._cache[(size, *self.border_radius)] = silhouette_surface
-
-            surface_filter = silhouette_surface
-
-        return surface_filter
-
-    def allow_focus_to_self(self)->bool:
-        return True
-
-    def enable(self) -> Self:
-        self.enabled = True
-        self.dirty_surface = True
-        return self
-
-    def disable(self) -> Self:
-        self.enabled = False
-        self.dirty_surface = True
-        return self
-
-    def is_enabled(self) -> bool:
-        return self.enabled
-
-    def set_callback(self, callback: Callable) -> Self:
-        self.callback = callback
-        return self
-
-    def on_get_focus(self):
-        super().on_get_focus()
-        if self.get_focus_sound and not self.silent_focus:
-            if self.parent_scene and self.parent_scene.visible:
-                bf.AudioManager().play_sound(self.get_focus_sound)
-        if self.silent_focus : 
-            self.silent_focus = False
-
-    def on_lose_focus(self):
-        super().on_lose_focus()
-        if self.lose_focus_sound and not self.silent_focus:
-            if self.parent_scene and self.parent_scene.visible:
-                bf.AudioManager().play_sound(self.lose_focus_sound)
-        if self.silent_focus : 
-            self.silent_focus = False
-
-    def __str__(self) -> str:
-        return f"ClickableWidget"
-
-    def click(self, force=False) -> None:
-        if not self.enabled and not force:
-            return
-        if self.callback is not None:
-            self.callback()
-
-    def do_on_click_down(self, button) -> None:
-        if self.enabled and button == 1 :
-            if not self.get_focus():
-                return
-            self.is_pressed = True
-            bf.AudioManager().play_sound(self.click_down_sound)
-
-            pygame.mouse.set_cursor(self.click_cursor)
-            self.set_relief(self.pressed_relief)
-
-    def do_on_click_up(self, button) -> None:
-        if self.enabled and button == 1 and self.is_pressed:
-            self.is_pressed = False
-            bf.AudioManager().play_sound(self.click_up_sound)
-            self.set_relief(self.unpressed_relief)
-            self.click()
-
-    def on_enter(self) -> None:
-        if not self.enabled:
-            return
-        super().on_enter()
-        self.dirty_surface  = True
-        pygame.mouse.set_cursor(self.hover_cursor)
-
-    def on_exit(self) -> None:
-        super().on_exit()
-        if self.is_pressed:
-            self.set_relief(self.unpressed_relief)
-        self.is_pressed    = False
-        self.dirty_surface  = True
-
-        pygame.mouse.set_cursor(bf.const.DEFAULT_CURSOR)
-
-    def on_lose_focus(self):
-        super().on_lose_focus()
-        self.on_exit()
-
-    def on_key_down(self, key):
-        if key == pygame.K_SPACE:
-            self.on_click_down(1)
-        super().on_key_down(key)
-
-    def on_key_up(self, key):
-        if key == pygame.K_SPACE:
-            self.on_click_up(1)
-        super().on_key_up(key)
-
-    def _paint_disabled(self) -> None:
-        self.surface.blit(
-            self.get_surface_filter(), (0, 0), special_flags=pygame.BLEND_RGB_SUB
-        )
-
-    def _paint_hovered(self) -> None:
-        self.surface.blit(
-            self.get_surface_filter(), (0, 0), special_flags=pygame.BLEND_RGB_ADD
-        )
-
-    def get_padded_rect(self)->pygame.FRect:
-        return pygame.FRect(
-            self.rect.x + self.padding[0], self.rect.y + self.padding[1] + (self.unpressed_relief - self.pressed_relief if  self.is_pressed else 0),
-            self.rect.w - self.padding[2] - self.padding[0],
-            self.rect.h - self.unpressed_relief - self.padding[1] - self.padding[3] #
-        )
-
-    def _get_elevated_rect(self) -> pygame.FRect:
-        return pygame.FRect(0,  self.unpressed_relief - self.pressed_relief if  self.is_pressed else 0 , self.rect.w, self.rect.h - self.unpressed_relief)
-
-    def paint(self) -> None:
-        super().paint()
-        if not self.enabled:
-            self._paint_disabled()
-        elif self.is_hovered:
-            self._paint_hovered()

batFramework/gui/constraints/__init__.py

@@ -1 +0,0 @@
-from . import constraints