batframework 1.1.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

batFramework/entity.py

@@ -1,123 +1,130 @@
-import pygame
-import batFramework as bf
-from typing import Any
-
-class Entity:
-    instance_num = 0
-    def __init__(
-        self,
-        size : None|tuple[int,int]=None,
-        no_surface : bool   =False,
-        surface_flags : int =0,
-        convert_alpha : bool=False
-    ) -> None:
-        self.convert_alpha = convert_alpha
-        if size is None:
-            size= (100,100)
-            
-        if no_surface:
-            self.surface = None
-        else:
-            self.surface = (pygame.Surface(size, surface_flags))
-
-        if convert_alpha and self.surface is not None:
-            self.surface = self.surface.convert_alpha()
-            self.surface.fill((0,0,0,0))
-
-        self.uid: Any = Entity.instance_num
-        self.tags: list[str] = []
-        self.parent_scene: bf.Scene | None = None
-        self.rect = pygame.FRect(0, 0, *size)
-        
-        self.visible = True
-        self._debug_color : tuple = bf.color.DARK_RED
-        self.render_order = 0
-        self.z_depth = 1
-        Entity.instance_num += 1
-
-    def get_bounding_box(self):
-        yield (self.rect,self._debug_color)
-
-    def set_debug_color(self, color):
-        self._debug_color = color
-
-    def set_visible(self, value: bool):
-        self.visible = value
-
-    def set_parent_scene(self, scene):
-        self.parent_scene = scene
-
-    def do_when_added(self):
-        pass
-
-    def do_when_removed(self):
-        pass
-
-    def set_position(self, x, y):
-        self.rect.topleft = (x, y)
-        return self
-
-    def set_x(self,x):
-        self.rect.x = x
-        return self
-
-    def set_y(self,y):
-        self.rect.y = y
-        return self
-
-    def set_center(self, x, y):
-        self.rect.center = (x, y)
-        return self
-
-    def set_uid(self, uid):
-        self.uid = uid
-        return self
-
-    def add_tag(self, *tags):
-        for tag in tags:
-            if tag not in self.tags:
-                self.tags.append(tag)
-        self.tags.sort()
-        return self
-
-    def remove_tag(self, *tags):
-        self.tags = [tag for tag in self.tags if tag not in tags]
-        self.tags.sort()
-
-    def has_tag(self, tag) -> bool:
-        return tag in 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_event(event)
-        self.do_reset_actions()
-        return res
-
-    def do_process_actions(self,event : pygame.Event)->None:
-        pass
-
-    def do_reset_actions(self)->None:
-        pass
-    
-    def do_handle_event(self, event: pygame.Event) -> bool:
-        return False
-
-    def update(self, dt: float):
-        self.do_update(dt)
-
-    def do_update(self,dt:float):
-        pass
-
-    def draw(self, camera: bf.Camera) -> int:
-        if not self.visible:
-            return False
-        if not self.surface or not camera.intersects(self.rect):
-            return False
-        camera.surface.blit(
-            self.surface,
-            tuple(round(i * self.z_depth) for i in camera.transpose(self.rect).topleft),
-        )
-        return True
+from typing import Any, Self
+import pygame
+import batFramework as bf
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .camera import Camera
+
+
+class Entity:
+    _count: int = 0
+    _available_uids: set[int] = set()
+
+    def __init__(self,*args,**kwargs) -> None:
+        if Entity._available_uids:
+            self.uid = Entity._available_uids.pop()
+        else:
+            self.uid = Entity._count
+            Entity._count += 1
+        size = kwargs.get("size",(10,10))
+        self.rect = pygame.FRect(0, 0, *size)
+        self.tags: list[str] = []
+        self.parent_scene: bf.Scene | None = None
+        self.parent_layer: bf.SceneLayer | None = None
+        self.debug_color: tuple | str = "red"
+
+    def __del__(self):
+        try:
+            Entity._available_uids.add(self.uid)
+        except AttributeError:
+            pass
+    def set_position(self, x, y) -> Self:
+        self.rect.topleft = x, y
+        return self
+
+    def set_center(self, x, y) -> Self:
+        self.rect.center = x, y
+        return self
+
+    def get_debug_outlines(self):
+        yield (self.rect, self.debug_color)
+
+    def set_debug_color(self, color) -> Self:
+        self.debug_color = color
+        return self
+
+    def kill(self):
+        """
+        Removes the entity from a scene layer
+        """
+        if self.parent_layer:
+            self.parent_layer.remove(self)
+
+    def set_parent_layer(self, layer):
+        self.parent_layer = layer
+
+    def set_parent_scene(self, scene) -> Self:
+        if scene == self.parent_scene:
+            return self
+        if self.parent_scene is not None:
+            self.do_when_removed()
+        self.parent_scene = scene
+        if scene is not None:
+            self.do_when_added()
+        return self
+
+    def do_when_added(self):
+        pass
+
+    def do_when_removed(self):
+        pass
+
+    def add_tags(self, *tags) -> Self:
+        for tag in tags:
+            if tag not in self.tags:
+                self.tags.append(tag)
+        self.tags.sort()
+        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 True if entity contains all given tags
+        """
+        return all(tag in self.tags for tag in tags)
+
+    def has_any_tags(self, *tags) -> bool:
+        """
+        return True if entity contains any of given tags
+        """
+        return any(tag in self.tags for tag in tags)
+
+    def get_tags(self) -> list[str]:
+        return self.tags
+
+    def process_event(self, event: pygame.Event) -> None:
+        if event.consumed:
+            return
+        self.process_actions(event)
+        self.handle_event(event)
+
+    def process_actions(self, event: pygame.Event) -> None:
+        """
+        Process entity actions you may have set
+        """
+
+    def reset_actions(self) -> None:
+        """
+        Reset entity actions you may have set
+        """
+
+    def handle_event(self, event: pygame.Event):
+        """
+        Handle specific events with no action support
+        """
+        return False
+
+    def update(self, dt: float) -> None:
+        """
+        Update method to be overriden by subclasses of Entity (must call do_update and reset_actions)
+        """
+        self.do_update(dt)
+        self.reset_actions()
+
+    def do_update(self, dt: float) -> None:
+        """
+        Update method to be overriden for specific behavior by the end user
+        """

batFramework/enums.py

@@ -0,0 +1,171 @@
+from enum import Enum
+import pygame
+
+playerInput = [pygame.KEYDOWN,pygame.MOUSEBUTTONDOWN,pygame.KEYUP,pygame.MOUSEBUTTONUP]
+
+class color:
+    WHITE = pygame.Color(255, 255, 255)
+    LIGHTER_GRAY = pygame.Color(236, 240, 241)
+    LIGHT_GRAY = pygame.Color(189, 195, 199)
+    DARK_GRAY = pygame.Color(66, 66, 66)
+    DARKER_GRAY = pygame.Color(23, 23, 23)
+    BLACK = pygame.Color(0, 0, 0)
+
+    TURQUOISE = pygame.Color(26, 188, 156)
+    TURQUOISE_SHADE = pygame.Color(22, 160, 133)
+
+    GREEN = pygame.Color(46, 204, 113)
+    GREEN_SHADE = pygame.Color(39, 174, 96)
+
+    BLUE = pygame.Color(52, 152, 219)
+    BLUE_SHADE = pygame.Color(41, 128, 185)
+
+    PURPLE = pygame.Color(155, 89, 182)
+    PURPLE_SHADE = pygame.Color(142, 68, 173)
+
+    CHARCOAL = pygame.Color(52, 73, 94)
+    CHARCOAL_SHADE = pygame.Color(44, 62, 80)
+
+    GOLD = pygame.Color(241, 196, 15)
+    GOLD_SHADE = pygame.Color(243, 156, 18)
+
+    ORANGE = pygame.Color(230, 126, 34)
+    ORANGE_SHADE = pygame.Color(211, 84, 0)
+
+    RED = pygame.Color(231, 76, 60)
+    RED_SHADE = pygame.Color(192, 57, 43)
+
+    CLOUD = pygame.Color(236, 240, 241)
+    CLOUD_SHADE = pygame.Color(189, 195, 199)
+
+    CONCRETE = pygame.Color(149, 165, 166)
+    CONCRETE_SHADE = pygame.Color(127, 140, 141)
+
+    # GB
+    DARKER_GB = pygame.Color(27, 42, 9)
+    DARK_GB = pygame.Color(14, 69, 11)
+    LIGHT_GB = pygame.Color(73, 107, 34)
+    LIGHTER_GB = pygame.Color(154, 158, 63)
+
+    @classmethod
+    def __iter__(cls):
+        for name, value in vars(cls).items():
+            if not name.startswith("__") and isinstance(value, pygame.Color):
+                yield value
+
+    @classmethod
+    def items(cls):
+        """Iterate over (name, color) pairs."""
+        for name, value in vars(cls).items():
+            if not name.startswith("__") and isinstance(value, pygame.Color):
+                yield name, value
+
+    @staticmethod
+    def mult(color: pygame.typing.ColorLike , factor: float):
+        color = pygame.Color(color)
+        return pygame.Color(
+            min(max(0, int(color[0] * factor)), 255),
+            min(max(0, int(color[1] * factor)), 255),
+            min(max(0, int(color[2] * factor)), 255),
+            color[3] if len(color)== 4 else 255
+        )
+
+    @staticmethod
+    def lerp(color1: pygame.Color | tuple[int, int, int, int], color2: pygame.Color | tuple[int, int, int, int], t: float) -> pygame.Color:
+        """Linearly interpolate between two colors."""
+        t = max(0.0, min(1.0, t))
+        c1 = color1 if isinstance(color1, (tuple, list)) else (color1.r, color1.g, color1.b, color1.a)
+        c2 = color2 if isinstance(color2, (tuple, list)) else (color2.r, color2.g, color2.b, color2.a)
+        return pygame.Color(
+            int(c1[0] + (c2[0] - c1[0]) * t),
+            int(c1[1] + (c2[1] - c1[1]) * t),
+            int(c1[2] + (c2[2] - c1[2]) * t),
+            int((c1[3] if len(c1) > 3 else 255) + ((c2[3] if len(c2) > 3 else 255) - (c1[3] if len(c1) > 3 else 255)) * t)
+        )
+
+    @staticmethod
+    def get_name(color_value:pygame.Color):
+        for name, val in color.__dict__.items():
+            # Only consider attributes that are pygame.Color instances
+            if isinstance(val, pygame.Color) and val == color_value:
+                return name
+        return str(color_value)
+    
+
+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.76,-0.36,0.41,1.34)
+
+    def __init__(self, *control_points):
+        self.control_points = control_points
+
+    @classmethod
+    def create(cls, *control_points):
+        """Create a custom easing instance."""
+        instance = object.__new__(cls)  
+        instance._value_ = control_points
+        instance.control_points = control_points
+        return instance
+
+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"
+    MIDTOP = "midtop"
+    MIDBOTTOM = "midbottom"
+    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
+    ALPHANUMERICAL = 3
+
+
+

batFramework/fontManager.py

@@ -0,0 +1,65 @@
+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_FONT_SIZE = 16
+        self.MIN_FONT_SIZE = 8
+        self.MAX_FONT_SIZE = 64
+        self.DEFAULT_ANTIALIAS = False
+        self.FONTS = {}
+
+    def set_default_antialias(self, value: bool):
+        self.DEFAULT_ANTIALIAS = value
+
+    def set_default_text_size(self, size: int):
+        self.DEFAULT_FONT_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+1, 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+1, 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/__init__.py

@@ -1,14 +1,28 @@
-from .constraints import *
-from .widget import Widget
-from .image import Image
-from .interactiveWidget import InteractiveWidget
-from .root import Root
-from .shape import Shape
-from .frame import Frame
-from .label import Label
-from .button import Button
-from .debugger import Debugger
-from .layout import *
-from .container import Container
-from .indicator import *
-from .toggle import Toggle
+from .widget import Widget
+from .styleManager import StyleManager
+from .style import Style
+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 .meter import BarMeter
+from .textWidget import TextWidget
+from .label import Label
+from .tooltip import ToolTip
+from .animatedLabel import AnimatedLabel
+from .textInput import TextInput
+from .button import Button
+from .debugger import *
+from .layout import *
+from .container import Container
+from .indicator import *
+from .toggle import Toggle
+from .syncedVar import SyncedVar
+from .radioButton import RadioButton
+from .slider import Slider
+from .selector import Selector
+from .scrollingContainer import ScrollingContainer
+from .collapseContainer import CollapseContainer
+import batFramework.gui.constraints as constraints

batFramework/gui/animatedLabel.py

@@ -0,0 +1,90 @@
+from .label import Label
+import batFramework as bf
+from typing import Self,Callable,Any
+
+
+class AnimatedLabel(Label):
+    def __init__(self,text="") -> None:
+        self.cursor_position: float = 0.0
+        self.text_speed: float = 20.0
+        self.is_over: bool = True
+        self.is_paused: bool = False
+        self.original_text = ""
+        self.end_callback : Callable[[],Any]= None
+        self.set_autoresize(False)
+        self.set_alignment(bf.alignment.LEFT)
+        super().__init__("")
+        self.set_text(text)
+
+    def __str__(self) -> str:
+        return "AnimatedLabel"
+
+    def set_end_callback(self,callback:Callable[[],Any]):
+        self.end_callback = callback
+
+    def pause(self) -> Self:
+        self.is_paused = True
+        return self
+
+    def resume(self) -> Self:
+        self.is_paused = False
+        return self
+
+    def set_text_speed(self, speed: float) -> Self:
+        self.text_speed = speed
+        return self
+
+    def cut_text_to_width(self, text: str) -> list[str]:
+        w = self.get_inner_width()
+        if text == "" or not self.text_widget.font_object or w < self.text_widget.font_object.point_size:
+            return [text]
+        left = 0
+        font_object = self.text_widget.font_object
+        for index in range(len(text)):
+            width = font_object.size(text[left:index])[0]
+
+            if width > w:
+                cut_point_start = index - 1
+                cut_point_end = index - 1
+                last_space = text.rfind(" ", 0, cut_point_start)
+                last_nline = text.rfind("\n", 0, cut_point_start)
+
+                if last_space != -1 or last_nline != -1:  # space was found !:
+                    cut_point_start = max(last_space, last_nline)
+                    cut_point_end = cut_point_start + 1
+                res = [text[:cut_point_start].strip()]
+                res.extend(self.cut_text_to_width(text[cut_point_end:].strip()))
+                return res
+            elif text[index] == "\n":
+                left = index
+        return [text]
+
+
+    def _set_text_internal(self,text:str)->Self:
+        super().set_text(text)
+        return self
+
+    def set_text(self,text:str)->Self:
+        self.original_text = text
+        self.is_over = False
+        self.cursor_position = 0
+
+    def set_size(self, size):
+        super().set_size(size)
+        self._set_text_internal('\n'.join(self.cut_text_to_width(self.original_text[: int(self.cursor_position)])))
+
+    def do_update(self, dt):
+        if self.is_over:
+            return
+        if not self.is_over and self.cursor_position == len(self.original_text):
+            if len(self.original_text) == 0:
+                self._set_text_internal("")
+            self.is_over = True
+            if self.end_callback is not None:
+                self.end_callback()
+            return
+        self.cursor_position = min(
+            self.cursor_position + self.text_speed * dt, len(self.original_text)
+        )
+        # self.set_text(self.original_text[: int(self.cursor_position)])
+        self._set_text_internal('\n'.join(self.cut_text_to_width(self.original_text[: int(self.cursor_position)])))