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

batFramework/debugger.py

@@ -0,0 +1,48 @@
+import batFramework as bf
+import pygame
+
+
+class Debugger(bf.Label):
+    def __init__(self, manager) -> None:
+        super().__init__()
+        self.manager: bf.Manager = manager
+        self.refresh_rate = 0
+        self._refresh_counter = 0
+        self.dynamic_data = {}
+        self.static_data = {}
+        self.render_order = 99
+        self.set_outline_color((20, 20, 20))
+        # self.set_background_color((0,0,0,0))
+        self.set_text_color("white")
+        # self.set_padding((30,30))
+        self.set_refresh_rate(20)
+        self.add_dynamic_data("FPS", lambda: str(round(self.manager.get_fps())))
+        self.add_dynamic_data("BLITS", lambda: str(self.parent_scene.blit_calls))
+        self.set_visible(False)
+
+    def set_refresh_rate(self, val: int):
+        self.refresh_rate = val
+
+    def update(self, dt: float):
+        visible = self.manager._debugging == 1
+        self.set_visible(visible)
+        if not visible:
+            return
+        self._refresh_counter -= dt * 60
+        if self._refresh_counter < 0:
+            self._refresh_counter = self.refresh_rate
+            self._refresh_debug_info()
+
+    def add_dynamic_data(self, key, func):
+        self.dynamic_data[key] = func
+
+    def set_static_data(self, key, value):
+        self.static_data[key] = value
+
+    def _refresh_debug_info(self):
+        lines = []
+        lines.extend([f"{key}:{value}" for key, value in self.static_data.items()])
+        lines.extend([f"{key}:{func()}" for key, func in self.dynamic_data.items()])
+        debug_text = "\n".join(lines)
+        self.set_text(debug_text)
+        self.update_surface()  # Update the surface after modifying the text

batFramework/dynamicEntity.py

@@ -2,16 +2,15 @@ import pygame
 import batFramework as bf
 from typing import Self
 
-
 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,
+        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,no_surface,surface_flags,convert_alpha)
         self.velocity = pygame.math.Vector2(0, 0)
 
     def on_collideX(self, collider: Self):
@@ -20,5 +19,5 @@ 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)->None:
+        self.set_position(self.rect.x + self.velocity.x, self.rect.y + self.velocity.y)

batFramework/easing.py

@@ -2,51 +2,47 @@ from enum import Enum
 import pygame
 import batFramework as bf
 
-
 class Easing(Enum):
-    EASE_IN = (0.12, 0, 0.39, 0)
-    EASE_OUT = (0.61, 1, 0.88, 1)
+    EASE_IN     = (0.12, 0, 0.39, 0)
+    EASE_OUT    = (0.61, 1, 0.88, 1)
     EASE_IN_OUT = (0.37, 0, 0.63, 1)
-    EASE_IN_OUT_ELASTIC = (0.7, -0.5, 0.3, 1.5)
-    LINEAR = (1, 1, 0, 0)
+    EASE_IN_OUT_ELASTIC = (.7,-0.5,.3,1.5)
+    LINEAR      = (1, 1, 0, 0)
     # Add more easing functions as needed
 
     def __init__(self, *control_points):
         self.control_points = control_points
 
-
 class EasingAnimation(bf.Timer):
     _cache = {}
-
     def __init__(
         self,
-        name: str = '',
-        easing_function: Easing = Easing.LINEAR,
-        duration: int = 100,
+        name:str=None,
+        easing_function:Easing=Easing.LINEAR,
+        duration:int=100,
         update_callback=None,
         end_callback=None,
-        loop: bool = False,
-        reusable: bool = False,
-    )->None:
+        loop:bool=False,
+        reusable:bool=False
+    ):
         self.easing_function = easing_function
         self.update_callback = update_callback
         self.value = 0.0
-        super().__init__(name, duration, loop, end_callback, reusable)
-
+        super().__init__(name,duration,loop,end_callback,reusable)
+        
     def get_value(self):
         return self.value
 
     def start(self):
-        self.value = 0
-        super().start()  # self.elapsed_progress set to 0 here
-
-    def update(self,dt) -> bool:
-        if super().update(dt):
-            return True  # If timer ended now, end() is called. So don't process value.
+        self.value =  0
+        super().start() # self.elapsed_progress set to 0 here    
+        
+    def update(self)->bool:
+        if super().update():
+            return True# If timer ended now, end() is called. So don't process value.  
         self._process_value()
         # if self.name == 0: print("UPDATING (callback) in easing")
-        if self.update_callback:
-            self.update_callback(self.value)
+        if self.update_callback: self.update_callback(self.value)
         return False
 
     def end(self):
@@ -54,14 +50,13 @@ class EasingAnimation(bf.Timer):
 
         self.elapsed_progress = 1
         self._process_value()
-        if self.update_callback:
-            self.update_callback(self.value)
-        self.value = 0
-        super().end()  # sets elapsed_progress to 0
+        if self.update_callback: self.update_callback(self.value)
+        self.value =  0
+        super().end() # sets elapsed_progress to 0
 
     def _process_value(self):
         p0, p1, p2, p3 = self.easing_function.control_points
-        cache_key = (self.easing_function,self.elapsed_progress, p0, p1, p2, p3)
+        cache_key = (self.elapsed_progress, p0, p1, p2, p3)
         if cache_key in EasingAnimation._cache:
             y = EasingAnimation._cache[cache_key]
         else:

batFramework/entity.py

@@ -1,59 +1,51 @@
-from typing import Any, Self
 import pygame
 import batFramework as bf
+from typing import Any
 
 class Entity:
-    """
-        Basic entity class
-    """
-    __instance_count = 0
-
+    instance_num = 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 = (10, 10)
+            size= (100,100)
+            
         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.rect = pygame.FRect(0, 0, *size)
+        self.uid: Any = Entity.instance_num
         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
+        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)
+        yield (self.rect,self._debug_color)
 
-    def set_debug_color(self, color) -> Self:
-        self.debug_color = color
-        return self
+    def set_debug_color(self, color):
+        self._debug_color = color
 
-    def set_visible(self, value: bool) -> Self:
+    def set_visible(self, value: bool):
         self.visible = value
-        return self
 
-    def set_parent_scene(self, scene) -> Self:
+    def set_parent_scene(self, scene):
         self.parent_scene = scene
-        return self
 
     def do_when_added(self):
         pass
@@ -61,100 +53,71 @@ class Entity:
     def do_when_removed(self):
         pass
 
-    def set_position(self, x, y) -> Self:
+    def set_position(self, x, y):
         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 set_x(self, x) -> Self:
+    def set_x(self,x):
         self.rect.x = x
         return self
 
-    def set_y(self, y) -> Self:
+    def set_y(self,y):
         self.rect.y = y
         return self
 
-    def set_center(self, x, y) -> Self:
+    def set_center(self, x, y):
         self.rect.center = (x, y)
         return self
 
-    def set_uid(self, uid) -> Self:
+    def set_uid(self, uid):
         self.uid = uid
         return self
 
-    def add_tags(self, *tags) -> 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_tags(self, *tags):
+    def remove_tag(self, *tags):
         self.tags = [tag for tag in self.tags if tag not in tags]
+        self.tags.sort()
 
-    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 has_tag(self, tag) -> bool:
+        return tag in 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_actions()
-        res = res or self.do_handle_event(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_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_reset_actions(self)->None:
+        pass
+    
     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):
-        """
-            Update method to be overriden for specific behavior by the end user
-        """
+    def do_update(self,dt:float):
+        pass
 
     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:
+            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

batFramework/gui/__init__.py

@@ -6,10 +6,8 @@ from .root import Root
 from .shape import Shape
 from .frame import Frame
 from .label import Label
-from .dialogueBox import DialogueBox
-from .textInput import TextInput
 from .button import Button
-from .debugger import *
+from .debugger import Debugger
 from .layout import *
 from .container import Container
 from .indicator import *

batFramework/gui/button.py

@@ -1,61 +1,25 @@
 from .label import Label
 import batFramework as bf
-from typing import Self,Callable
+from types import FunctionType
+from typing import Self
 from .interactiveWidget import InteractiveWidget
 import pygame
 
-
-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
+class Button(Label,InteractiveWidget):
+    _cache = {}
+    
+    def __init__(self, text: str, callback : FunctionType =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.effect :float = 0
-        self.enabled :bool = True
         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:
+    def set_callback(self,callback : FunctionType = None)->Self:
         self.callback = callback
         return self
 
@@ -67,84 +31,54 @@ class Button(Label, InteractiveWidget):
         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 to_string_id(self)->str:
+        return f"Button({self._text})"   
 
-
-    def do_on_click_down(self,button)->None:
-        if self.enabled and button == 1 and self.effect == 0:
-            if not self.get_focus():return
+    def click(self)->None:
+        if self.callback and not self.is_clicking:
             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.callback()
             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 do_process_actions(self,event):
+        self.click_action.process_event(event)
+        self.hover_action.process_event(event)
+
+    def do_reset_actions(self):
+        self.click_action.reset()
+        self.hover_action.reset()
+
+    def do_handle_event(self,event)->None:
+        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()
+        elif self.hover_action.is_active():
+            root = self.get_root()
+            if root:
+                if self.is_hovered and root.hovered != self:
+                    self.is_hovered = False
+                    self.build()
+                if not self.is_hovered and root.hovered == self:
+                    self.is_hovered = True
+                    self.build()
+        return res
+
+
+        
+    def build(self)->None:
+        super().build()
+        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)
 
-    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()
+    def apply_contraints(self)->None:
+        super().apply_contraints()