batframework 1.0.6__py3-none-any.whl → 1.0.8a1__py3-none-any.whl

batFramework/dynamicEntity.py

@@ -7,11 +7,10 @@ class DynamicEntity(bf.Entity):
     def __init__(
         self,
         size: None | tuple[int, int] = None,
-        no_surface: bool = False,
         surface_flags: int = 0,
         convert_alpha: bool = False,
     ) -> None:
-        super().__init__(size, no_surface, surface_flags, convert_alpha)
+        super().__init__(size, surface_flags, convert_alpha)
         self.velocity = pygame.math.Vector2(0, 0)
 
     def on_collideX(self, collider: Self):
@@ -20,5 +19,7 @@ class DynamicEntity(bf.Entity):
     def on_collideY(self, collider: Self):
         return False
 
-    def move_by_velocity(self,dt) -> None:
-        self.set_position(self.rect.x + self.velocity.x * dt, self.rect.y + self.velocity.y * dt)
+    def move_by_velocity(self, dt) -> None:
+        self.set_position(
+            self.rect.x + self.velocity.x * dt, self.rect.y + self.velocity.y * dt
+        )

batFramework/easingController.py

@@ -0,0 +1,58 @@
+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/entity.py

@@ -1,160 +1,67 @@
 from typing import Any, Self
 import pygame
 import batFramework as bf
+from .object import Object
 
-class Entity:
+class Entity(Object):
     """
-        Basic entity class
+    Basic entity class
     """
-    __instance_count = 0
-
     def __init__(
         self,
         size: None | tuple[int, int] = None,
-        no_surface: bool = False,
         surface_flags: int = 0,
         convert_alpha: bool = False,
+        *args,
+        **kwargs,
     ) -> None:
-        self.convert_alpha = convert_alpha
-        if size is None:
-            size = (10, 10)
-        if no_surface:
-            self.surface = None
-        else:
-            self.surface = pygame.Surface(size, surface_flags)
-            
-        if convert_alpha and self.surface is not None:
+        super().__init__()
+        self.visible: bool = True
+        self.rect.size = (10, 10) if size is None else size
+        self.convert_alpha: bool = convert_alpha
+        self.surface_flags: int = surface_flags
+        self.blit_flags: int = 0
+        self.surface: pygame.Surface = pygame.Surface(self.rect.size, surface_flags)
+        if convert_alpha:
             self.surface = self.surface.convert_alpha()
             self.surface.fill((0, 0, 0, 0))
 
-        self.rect = pygame.FRect(0, 0, *size)
-        self.tags: list[str] = []
-        self.parent_scene: bf.Scene | None = None
-        self.visible: bool = True
-        self.debug_color: tuple = bf.color.DARK_RED
-        self.render_order: int = 0
-        self.uid: Any = Entity.__instance_count
-        Entity.__instance_count += 1
-
-    def set_render_order(self, render_order: int) -> Self:
-        self.render_order = render_order
-        return self
-
-    def get_bounding_box(self):
-        yield (self.rect, self.debug_color)
-
-    def set_debug_color(self, color) -> Self:
-        self.debug_color = color
-        return self
-
-    def set_visible(self, value: bool) -> Self:
-        self.visible = value
-        return self
-
-    def set_parent_scene(self, scene) -> Self:
-        self.parent_scene = scene
+    def set_alpha(self, alpha: int) -> Self:
+        self.surface.set_alpha(min(max(0, alpha), 255))
         return self
 
-    def do_when_added(self):
-        pass
-
-    def do_when_removed(self):
-        pass
-
-    def set_position(self, x, y) -> Self:
-        self.rect.topleft = (x, y)
-        return self
-
-    def get_position(self) -> tuple:
-        return self.rect.topleft
-
-    def get_center(self) -> tuple:
-        return self.rect.center
+    def get_alpha(self)->int:
+        return self.surface.get_alpha()
 
-    def set_x(self, x) -> Self:
-        self.rect.x = x
+    def set_surface_flags(self, surface_flags: int) -> Self:
+        self.surface_flags = surface_flags
         return self
 
-    def set_y(self, y) -> Self:
-        self.rect.y = y
+    def set_convert_alpha(self, value: bool) -> Self:
+        self.convert_alpha = value
         return self
 
-    def set_center(self, x, y) -> Self:
-        self.rect.center = (x, y)
+    def set_blit_flags(self, blit_flags: int) -> Self:
+        self.blit_flags = blit_flags
         return self
 
-    def set_uid(self, uid) -> Self:
-        self.uid = uid
+    def set_render_order(self, render_order: int) -> Self:
+        self.render_order = render_order
+        if self.parent_scene:
+            self.parent_scene.sort_entities()
         return self
 
-    def add_tags(self, *tags) -> Self:
-        for tag in tags:
-            if tag not in self.tags:
-                self.tags.append(tag)
-        self.tags.sort()
+    def set_visible(self, value: bool) -> Self:
+        self.visible = value
         return self
 
-    def remove_tags(self, *tags):
-        self.tags = [tag for tag in self.tags if tag not in tags]
-
-    def has_tags(self, *tags) -> bool:
-        return all(tag in self.tags for tag in tags)
-
-    def get_tags(self) -> list[str]:
-        return self.tags
-
-    def process_event(self, event: pygame.Event) -> bool:
-        """
-        Returns bool : True if the method is blocking (no propagation to next children of the scene)
-        """
-        self.do_process_actions(event)
-        res = self.do_handle_actions()
-        res = res or self.do_handle_event(event)
-        self.do_reset_actions()
-        return res
-
-
-
-    def do_process_actions(self, event: pygame.Event) -> None:
-        """
-            Process entity actions you may have set
-        """
-
-    def do_reset_actions(self) -> None:
-        """
-            Reset entity actions you may have set
-        """
-
-    def do_handle_actions(self) ->None:
-        """
-            Handle entity actions
+    def draw(self, camera: bf.Camera) -> None:
         """
-
-    def do_handle_event(self, event: pygame.Event) -> bool:
-        """
-            Handle specific
+        Draw the entity onto the camera surface
         """
-
-        return False
-
-    def update(self, dt: float):
-        """
-            Update method to be overriden by subclasses of widget
-        """
-        self.do_update(dt)
-
-    def do_update(self, dt: float):
-        """
-            Update method to be overriden for specific behavior by the end user
-        """
-
-    def draw(self, camera: bf.Camera) -> int:
-        """
-            Draw the entity onto the camera with coordinate transposing
-        """
-        should_not_draw = not self.visible or not self.surface or not camera.intersects(self.rect)
-        if should_not_draw:
-            return 0
-        camera.surface.blit(self.surface, camera.transpose(self.rect))
-
-        return 1
+        if not self.visible or not camera.rect.colliderect(self.rect): return
+        camera.surface.blit(
+            self.surface,
+            camera.world_to_screen(self.rect),
+            special_flags=self.blit_flags,
+        )

batFramework/enums.py

@@ -1,14 +1,104 @@
 from enum import Enum
 
-class Direction(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 Alignment(Enum):
+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,8 +1,11 @@
 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()
@@ -12,10 +15,13 @@ class FontManager(metaclass=Singleton):
         self.DEFAULT_ANTIALIAS = False
         self.FONTS = {}
 
-    def set_default_text_size(self,size: int):
+    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):
+    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)
@@ -24,14 +30,14 @@ class FontManager(metaclass=Singleton):
             self.load_sysfont(raw_path)
             self.load_sysfont(raw_path, None)
 
-    def load_font(self,path: str|None, name: str|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
+
+        # get filename if path is given, else None
         if name != "":
             filename = name  # if name is not given, name is the filename
         self.FONTS[filename] = {}
@@ -39,7 +45,7 @@ class FontManager(metaclass=Singleton):
         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= ""):
+    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:
@@ -49,7 +55,9 @@ class FontManager(metaclass=Singleton):
         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:
+    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]:

batFramework/gui/__init__.py

@@ -2,9 +2,11 @@ from .constraints import *
 from .widget import Widget
 from .image import Image
 from .interactiveWidget import InteractiveWidget
+from .draggableWidget import DraggableWidget
+from .clickableWidget import ClickableWidget
 from .root import Root
 from .shape import Shape
-from .frame import Frame
+from .meter import Meter
 from .label import Label
 from .dialogueBox import DialogueBox
 from .textInput import TextInput
@@ -14,3 +16,5 @@ from .layout import *
 from .container import Container
 from .indicator import *
 from .toggle import Toggle
+from .radioButton import RadioButton,RadioVariable
+from .slider import Slider

batFramework/gui/button.py

@@ -1,150 +1,12 @@
 from .label import Label
 import batFramework as bf
-from typing import Self,Callable
-from .interactiveWidget import InteractiveWidget
+from typing import Self, Callable
+from .clickableWidget import ClickableWidget
 import pygame
+from math import ceil
 
 
-class Button(Label, InteractiveWidget):
-    _cache :dict = {}
-
-    def __init__(self, text: str, callback: None| Callable = None) -> None:
-        # Label.__init__(self,text)
-        self.callback = callback
-        self.is_hovered: bool = False
-        self.effect_max :float= 20
-        self.effect_speed :float= 1.8
-        self.is_clicking : bool = False
-        self.effect :float = 0
-        self.enabled :bool = True
+class Button(Label, ClickableWidget):
+    def __init__(self, text: str, callback: None | Callable = None) -> None:
         super().__init__(text=text)
-        self.set_debug_color("cyan")
-        self.focusable = True
-
-    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:
-                # Create a mask from the original surface
-                mask = pygame.mask.from_surface(self.surface,threshold=0)
-
-                # Get the bounding box of the mask
-                silhouette_surface = mask.to_surface(
-                    setcolor = (30,30,30),unsetcolor= (255,255,255)
-                ).convert_alpha()
-                
-
-                Button._cache[size] = silhouette_surface
-                surface_filter = silhouette_surface
-
-            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
-
-    def on_get_focus(self):
-        super().on_get_focus()
-        self.build()
-
-    def on_lose_focus(self):
-        super().on_lose_focus()
-        self.build()
-
-    def to_string_id(self) -> str:
-        return f"Button({self._text}){'' if self.enabled else '[disabled]'}"
-
-    def click(self) -> None:
-        if self.callback is not None:
-            self.callback()
-            bf.Timer(duration=0.3,end_callback=self._safety_effect_end).start()
-
-    def _safety_effect_end(self)->None:
-        if self.effect > 0:
-            self.effect = 0
-            self.build()
-                    
-    def start_effect(self):
-        if self.effect <= 0 : self.effect = self.effect_max
-
-
-    def do_on_click_down(self,button)->None:
-        if self.enabled and button == 1 and self.effect == 0:
-            if not self.get_focus():return
-            self.is_clicking = True
-            self.start_effect()
-
-    def do_on_click_up(self,button)->None:
-        if self.enabled and button == 1 and self.is_clicking: 
-            # self.effect = 0
-            self.is_clicking = False
-            self.build()
-            self.click()
-    
-    def on_enter(self)->None:
-        if not self.enabled : return
-        super().on_enter()
-        self.effect = 0
-        self.build()
-        pygame.mouse.set_cursor(*pygame.cursors.tri_left)
-
-    def on_exit(self)->None:
-        super().on_exit()
-        # self.effect = 0
-        self.is_clicking = False
-        self.build()
-        pygame.mouse.set_cursor(pygame.cursors.arrow)
-
-
-
-    def update(self,dt):
-        super().update(dt)
-        if self.effect <= 0: return
-        self.effect -= dt*60*self.effect_speed
-        if self.is_clicking:
-            if self.effect < 1 : self.effect = 1
-        else:
-            if self.effect < 0 : self.effect = 0
-        self.build()
-
-    def _build_effect(self)->None:
-        if self.effect < 1 : return
-        e = int(min(self.rect.w //3, self.rect.h//3,self.effect))
-        pygame.draw.rect(
-            self.surface,
-            bf.color.CLOUD_WHITE,
-            (0,0,*self.surface.get_size()),
-            #int(self.effect),
-            e,
-            *self._border_radius
-            )
-    def _build_disabled(self)->None:
-        self.surface.blit(self.get_surface_filter(), (0, 0), special_flags=pygame.BLEND_SUB)
-
-    def _build_hovered(self)->None:
-        self.surface.blit(self.get_surface_filter(), (0, 0), special_flags=pygame.BLEND_ADD)
-
-    def build(self) -> None:
-        super().build()
-        if not self.enabled:
-            self._build_disabled()
-        elif self.is_hovered:
-            self._build_hovered()
-        if self.effect:
-            self._build_effect()
+        self.set_callback(callback)