batframework 0.1.13__py3-none-any.whl → 1.0.1__py3-none-any.whl

batFramework/entity.py

@@ -1,51 +1,59 @@
+from typing import Any, Self
 import pygame
 import batFramework as bf
-from typing import Any
 
 class Entity:
-    instance_num = 0
+    """
+        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
+        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)
-            
+            size = (10, 10)
         if no_surface:
             self.surface = None
         else:
-            self.surface = (pygame.Surface(size, surface_flags))
-
+            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.surface.fill((0, 0, 0, 0))
 
-        self.uid: Any = Entity.instance_num
+        self.rect = pygame.FRect(0, 0, *size)
         self.tags: list[str] = []
         self.parent_scene: bf.Scene | None = None
-        self.rect = pygame.FRect(0, 0, *size)
-        
-        self.visible :bool = True
-        self._debug_color : tuple = bf.color.DARK_RED
-        self.render_order :int = 0
-        self.z_depth :float = 1
-        Entity.instance_num += 1
+        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)
+        yield (self.rect, self.debug_color)
 
-    def set_debug_color(self, color):
-        self._debug_color = color
+    def set_debug_color(self, color) -> Self:
+        self.debug_color = color
+        return self
 
-    def set_visible(self, value: bool):
+    def set_visible(self, value: bool) -> Self:
         self.visible = value
+        return self
 
-    def set_parent_scene(self, scene):
+    def set_parent_scene(self, scene) -> Self:
         self.parent_scene = scene
+        return self
 
     def do_when_added(self):
         pass
@@ -53,70 +61,100 @@ class Entity:
     def do_when_removed(self):
         pass
 
-    def set_position(self, x, y):
+    def set_position(self, x, y) -> Self:
         self.rect.topleft = (x, y)
         return self
 
-    def set_x(self,x):
+    def get_position(self) -> tuple:
+        return self.rect.topleft
+
+    def get_center(self) -> tuple:
+        return self.rect.center
+
+    def set_x(self, x) -> Self:
         self.rect.x = x
         return self
 
-    def set_y(self,y):
+    def set_y(self, y) -> Self:
         self.rect.y = y
         return self
 
-    def set_center(self, x, y):
+    def set_center(self, x, y) -> Self:
         self.rect.center = (x, y)
         return self
 
-    def set_uid(self, uid):
+    def set_uid(self, uid) -> Self:
         self.uid = uid
         return self
 
-    def add_tag(self, *tags):
+    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_tag(self, *tags):
+    def remove_tags(self, *tags):
         self.tags = [tag for tag in self.tags if tag not in tags]
 
-    def has_tag(self, tag) -> bool:
-        return tag in self.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:
+    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)
+        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:
-        pass
 
-    def do_reset_actions(self)->None:
-        pass
-    
+
+    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 do_handle_event(self, event: pygame.Event) -> bool:
+        """
+            Handle specific
+        """
+
         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):
-        pass
+    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:
-        if not self.visible:
-            return 0
-        if not self.surface or not camera.intersects(self.rect):
+        """
+            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,
-            tuple(round(i * self.z_depth) for i in camera.transpose(self.rect).topleft),
-        )
+        camera.surface.blit(self.surface, camera.transpose(self.rect))
+
         return 1

batFramework/enums.py

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,57 @@
+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]

batFramework/gui/__init__.py

@@ -5,9 +5,9 @@ from .interactiveWidget import InteractiveWidget
 from .root import Root
 from .shape import Shape
 from .frame import Frame
-from .label import Label,Align
+from .label import Label, Align
 from .button import Button
-from .debugger import Debugger
+from .debugger import *
 from .layout import *
 from .container import Container
 from .indicator import *

batFramework/gui/button.py

@@ -1,25 +1,50 @@
 from .label import Label
 import batFramework as bf
-from types import FunctionType
-from typing import Self
+from typing import Self,Callable
 from .interactiveWidget import InteractiveWidget
 import pygame
 
-class Button(Label,InteractiveWidget):
+
+class Button(Label, InteractiveWidget):
     _cache = {}
-    
-    def __init__(self, text: str, callback : FunctionType =None) -> None:
-        # Label.__init__(self,text) 
-        self.callback = callback    
+
+    def __init__(self, text: str, callback: None| Callable = None) -> None:
+        # Label.__init__(self,text)
+        self.callback = callback
         self.click_action = bf.Action("click").add_mouse_control(1)
         self.hover_action = bf.Action("hover").add_mouse_control(pygame.MOUSEMOTION)
-        self.is_hovered : bool = False
-        self.is_clicking : bool = False
+        self.is_hovered: bool = False
+        self.is_clicking: bool = False
+        self.effect_max :float= 20
+        self.effect_speed :float= 1.2
+        self.effect :float = 0
+        self.enabled :bool = True
         super().__init__(text=text)
         self.set_debug_color("cyan")
 
+    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:
+            surface_filter = pygame.Surface(size).convert_alpha()
+            surface_filter.fill((30, 30, 30, 0))
+            Button._cache[size] = surface_filter
+        return surface_filter
+    def enable(self)->Self:
+        self.enabled = True
+        self.build()
+        return self
 
-    def set_callback(self,callback : FunctionType = None)->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
 
@@ -31,17 +56,19 @@ class Button(Label,InteractiveWidget):
         super().on_lose_focus()
         self.build()
 
-    def to_string_id(self)->str:
-        return f"Button({self._text})"   
+    def to_string_id(self) -> str:
+        return f"Button({self._text}){'' if self.enabled else '[disabled]'}"
 
-    def click(self)->None:
-        if self.callback and not self.is_clicking:
+    def click(self) -> None:
+        if self.callback is not None and not self.is_clicking:
             self.is_clicking = True
             self.callback()
             self.is_clicking = False
-            
-            
-    def do_process_actions(self,event):
+
+    def start_effect(self):
+        if self.effect <= 0 : self.effect = self.effect_max
+
+    def do_process_actions(self, event):
         self.click_action.process_event(event)
         self.hover_action.process_event(event)
 
@@ -49,13 +76,16 @@ class Button(Label,InteractiveWidget):
         self.click_action.reset()
         self.hover_action.reset()
 
-    def do_handle_event(self,event)->None:
+    def do_handle_event(self, event) -> bool:
         res = False
         if self.click_action.is_active():
             root = self.get_root()
-            if root.hovered ==  self:
-                if not self.is_focused :  self.get_focus()
-                self.click()
+            if root is None : return res
+            if root.get_hovered() == self and self.enabled:
+                if not self.is_focused:
+                    self.get_focus()
+                # self.click()
+                self.start_effect()
                 res = True
         elif self.hover_action.is_active():
             root = self.get_root()
@@ -70,18 +100,39 @@ class Button(Label,InteractiveWidget):
                     res = True
         return res
 
+    def update(self,dt):
+        super().update(dt)
+        if self.effect > 0:
+            self.effect -= dt*60*self.effect_speed
+            self.build()
+            if self.effect <= 0:
+                self.is_hovered = False
+                self.effect = 0
+                self.click()
+                self.build()
 
-        
-    def build(self)->None:
+    def _build_effect(self)->None:
+        pygame.draw.rect(
+            self.surface,
+            bf.color.CLOUD_WHITE,
+            (0,0,*self.surface.get_size()),
+            int(self.effect),
+            *self._border_radius
+            )
+                
+    def build(self) -> None:
         super().build()
+        size = self.surface.get_size()
+        if not self.enabled:
+            self.surface.blit(self.get_surface_filter(), (0, 0), special_flags=pygame.BLEND_SUB)
+            return
+        if self.effect:
+            if self.effect >= 1 : 
+                self._build_effect()
+            return
         if self.is_hovered:
-            hover_surf = Button._cache.get(self.surface.get_size(),None)
-            if hover_surf is None:
-                hover_surf = pygame.Surface(self.surface.get_size()).convert_alpha()
-                hover_surf.fill((30,30,30,0))
-                Button._cache[self.surface.get_size()] = hover_surf
-            self.surface.blit(hover_surf,(0,0),special_flags = pygame.BLEND_ADD)
+            self.surface.blit(self.get_surface_filter(), (0, 0), special_flags=pygame.BLEND_ADD)
 
+    def apply_contraints(self) -> None:
+        super().apply_constraints()
 
-    def apply_contraints(self)->None:
-        super().apply_contraints()