batframework 1.0.9a10__py3-none-any.whl → 1.0.10__py3-none-any.whl

batFramework/entity.py

@@ -1,68 +1,51 @@
-from typing import Any, Self
 import pygame
 import batFramework as bf
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from .camera import Camera
-
+from typing import Any
 
 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()
+    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.uid = Entity._count
-            Entity._count += 1
+            self.surface = (pygame.Surface(size, surface_flags))
 
-        self.rect = pygame.FRect(0, 0, 10, 10)
+        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.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
+        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 set_center(self, x, y) -> Self:
-        self.rect.center = x, y
-        return self
+    def get_bounding_box(self):
+        yield (self.rect,self._debug_color)
 
-    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_debug_color(self, color):
+        self._debug_color = color
 
-    def set_parent_layer(self, layer):
-        self.parent_layer = layer
+    def set_visible(self, value: bool):
+        self.visible = value
 
-    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()
+    def set_parent_scene(self, scene):
         self.parent_scene = scene
-        if scene is not None:
-            self.do_when_added()
-        return self
 
     def do_when_added(self):
         pass
@@ -70,61 +53,71 @@ class Entity:
     def do_when_removed(self):
         pass
 
-    def add_tags(self, *tags) -> Self:
+    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_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 True if entity contains all given tags
-        """
-        return all(tag in self.tags for tag in tags)
+    def has_tag(self, tag) -> bool:
+        return tag in self.tags
 
-    def has_any_tags(self, *tags) -> bool:
+    def process_event(self, event: pygame.Event)->bool:
         """
-        return True if entity contains any of given tags
+        Returns bool : True if the method is blocking (no propagation to next children of the scene)
         """
-        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.do_process_actions(event)
-        self.do_handle_event(event)
-
-    def do_process_actions(self, event: pygame.Event) -> None:
-        """
-        Process entity actions you may have set
-        """
+        res = self.do_handle_event(event)
+        self.do_reset_actions()
+        return res
 
-    def do_reset_actions(self) -> None:
-        """
-        Reset entity actions you may have set
-        """
+    def do_process_actions(self,event : pygame.Event)->None:
+        pass
 
-    def do_handle_event(self, event: pygame.Event):
-        """
-        Handle specific events with no action support
-        """
+    def do_reset_actions(self)->None:
+        pass
+    
+    def do_handle_event(self, event: pygame.Event) -> bool:
         return False
 
-    def update(self, dt: float) -> None:
-        """
-        Update method to be overriden by subclasses of Entity (must call do_update and do_reset_actions)
-        """
+    def update(self, dt: float):
         self.do_update(dt)
-        self.do_reset_actions()
 
-    def do_update(self, dt: float) -> None:
-        """
-        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:
+        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

@@ -1,25 +1,14 @@
+from .constraints import *
 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 .frame import Frame
 from .label import Label
-from .tooltip import ToolTip
-from .animatedLabel import AnimatedLabel
-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 *
 from .toggle import Toggle
-from .syncedVar import SyncedVar
-from .radioButton import RadioButton
-from .slider import Slider
-from .selector import Selector
-import batFramework.gui.constraints as constraints

batFramework/gui/button.py

@@ -1,18 +1,84 @@
 from .label import Label
 import batFramework as bf
-from typing import Self, Callable,Any
-from .clickableWidget import ClickableWidget
+from types import FunctionType
+from typing import Self
+from .interactiveWidget import InteractiveWidget
+import pygame
 
-
-class Button(Label, ClickableWidget):
-    def __init__(self, text: str = "", callback: Callable[[],Any] = None) -> None:
+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
         super().__init__(text=text)
-        self.set_callback(callback)
+        self.set_debug_color("cyan")
+
+
+    def set_callback(self,callback : FunctionType = None)->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})"   
+
+    def click(self)->None:
+        if self.callback and not self.is_clicking:
+            self.is_clicking = True
+            self.callback()
+            self.is_clicking = False
+            
+            
+    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 __str__(self) -> str:
-        return f"Button('{self.text}')"
 
-    def get_min_required_size(self):
-        res = super().get_min_required_size()
-        res = res[0],res[1]+self.unpressed_relief
-        return res
+    def apply_contraints(self)->None:
+        super().apply_contraints() 

batFramework/gui/constraints.py

@@ -0,0 +1,204 @@
+from .widget import Widget
+import batFramework as bf
+
+
+class Constraint:
+    def __init__(self,name="Constraint", priority=0):
+        self.priority = priority
+        self.name = name
+    def set_priority(self, priority)->"Constraint":
+        self.priority = priority
+        return self
+    def to_string(self)->str:
+        return f"{self.name.upper()}"
+        
+    def evaluate(self, parent_widget:Widget, child_widget:Widget) -> bool:
+        raise NotImplementedError("Subclasses must implement evaluate method")
+
+    def apply(self, parent_widget:Widget, child_widget:Widget=None) -> bool:
+        if not self.evaluate(parent_widget, child_widget):
+            self.apply_constraint(parent_widget, child_widget)
+            return False
+        return True
+        
+    def apply_constraint(self, parent_widget:Widget, child_widget:Widget):
+        raise NotImplementedError("Subclasses must implement apply_constraint method")
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+class ConstraintMinWidth(Constraint):
+    def __init__(self, width):
+        super().__init__(name="min_width")
+        self.min_width = width
+
+    def evaluate(self, parent_widget, child_widget):
+        return child_widget.rect.width >= self.min_width
+
+    def apply_constraint(self, parent_widget, child_widget):
+        if not self.evaluate(parent_widget, child_widget):
+            child_widget.set_size(self.min_width,child_widget.rect.h)
+
+
+            
+    
+class ConstraintCenterX(Constraint):
+    def __init__(self):
+        super().__init__(name="centerx")
+
+    def evaluate(self, parent_widget, child_widget):
+        return child_widget.rect.centerx == parent_widget.get_content_center()[0]
+
+    def apply_constraint(self,parent_widget,child_widget):
+        if not self.evaluate(parent_widget,child_widget):
+            child_widget.set_center(parent_widget.get_content_center()[0],child_widget.rect.centery)
+
+class ConstraintCenterY(Constraint):
+    def __init__(self):
+        super().__init__(name="centery")
+
+    def evaluate(self, parent_widget, child_widget):
+        return child_widget.rect.centery == parent_widget.get_content_center()[1]
+
+    def apply_constraint(self,parent_widget,child_widget):
+        if not self.evaluate(parent_widget,child_widget):
+            child_widget.set_center(child_widget.rect.centerx,parent_widget.get_content_center()[1])
+
+class ConstraintCenter(Constraint):
+    def __init__(self):
+        super().__init__(name="center")
+
+    def evaluate(self, parent_widget, child_widget):
+        return child_widget.rect.center == parent_widget.get_content_center()
+
+    def apply_constraint(self,parent_widget,child_widget):
+        if not self.evaluate(parent_widget,child_widget):
+            child_widget.set_center(*parent_widget.get_content_center())
+
+class ConstraintPercentageWidth(Constraint):
+    def __init__(self,percentage:float,keep_autoresize:bool=True):
+        super().__init__(name="percentage_width")
+        self.percentage:float = percentage
+        self.keep_autoresize: bool = keep_autoresize
+    def to_string(self)->str:
+        return f"{super().to_string()}.[{self.percentage},{self.keep_autoresize}]"
+    def evaluate(self, parent_widget, child_widget):
+        return child_widget.rect.width == round(parent_widget.get_content_width() * self.percentage)
+
+    def apply_constraint(self,parent_widget,child_widget):
+        if not self.evaluate(parent_widget,child_widget):
+            if child_widget.autoresize:
+                if self.keep_autoresize:
+                    print(f"Warning: Constraint on {child_widget.to_string()} can't resize, autoresize set to True")
+                    return 
+                child_widget.set_autoresize(False)
+            child_widget.set_size(round(parent_widget.get_content_width() * self.percentage) ,child_widget.rect.h)
+
+
+class ConstraintPercentageHeight(Constraint):
+    def __init__(self,percentage:float,keep_autoresize:bool=True):
+        super().__init__(name="percentage_height")
+        self.percentage:float = percentage
+        self.keep_autoresize: bool = keep_autoresize
+
+    def evaluate(self, parent_widget, child_widget):
+        return child_widget.rect.height == round(parent_widget.get_content_height() * self.percentage)
+
+    def apply_constraint(self,parent_widget,child_widget):
+        if not self.evaluate(parent_widget,child_widget):
+            if child_widget.autoresize:
+                if self.keep_autoresize:
+                    print(f"Warning: Constraint on {child_widget.to_string()} can't resize, autoresize set to True")
+                    return 
+                child_widget.set_autoresize(False)
+            child_widget.set_size(child_widget.rect.w,round(parent_widget.get_content_height() * self.percentage))
+
+class ConstraintHeight(Constraint):
+    def __init__(self,height:float):
+        if height < 0 :
+            raise ValueError("height can't be negative")
+        super().__init__(name="height")
+        self.height = height
+
+    def to_string(self)->str:
+        return f"{super().to_string()}.({self.height})"
+
+    def evaluate(self, parent_widget, child_widget):
+        return child_widget.rect.height == self.height
+
+    def apply_constraint(self,parent_widget,child_widget):
+        if not self.evaluate(parent_widget,child_widget):
+            child_widget.set_size(child_widget.rect.w,self.height)
+
+class ConstraintWidth(Constraint):
+    def __init__(self,width:float):
+        if width < 0 :
+            raise ValueError("width can't be negative")
+        super().__init__(name="width")
+        self.width = width
+
+    def to_string(self)->str:
+        return f"{super().to_string()}.({self.width})"
+
+    def evaluate(self, parent_widget, child_widget):
+        return child_widget.rect.width == self.width
+
+    def apply_constraint(self,parent_widget,child_widget):
+        if not self.evaluate(parent_widget,child_widget):
+            child_widget.set_size(self.width,child_widget.rect.h)
+
+
+class ConstraintAspectRatio(Constraint):
+    def __init__(self,ratio:int|float=1):
+        super().__init__(name="aspect_ratio")
+        if isinstance(ratio, float|int):
+            self.ratio = ratio
+        elif isinstance(ratio,Widget):
+            self.ratio = ratio.rect.w / ratio.rect.h
+        else:
+            raise TypeError(f"Ratio must be float or Widget")
+    def evaluate(self, parent_widget,child_widget):
+        return  self.ratio  ==  child_widget.rect.w / child_widget.rect.h
+        
+    def apply_constraint(self,parent_widget,child_widget):
+        if not self.evaluate(parent_widget,child_widget):
+            return # TODO
+    
+class ConstraintAnchorBottom(Constraint):
+    def __init__(self):
+        super().__init__(name="anchor_bottom")
+        
+    def evaluate(self, parent_widget,child_widget):
+        return  child_widget.rect.bottom == parent_widget.rect.bottom
+        
+    def apply_constraint(self,parent_widget,child_widget):
+        if not self.evaluate(parent_widget,child_widget):
+            child_widget.set_y(parent_widget.get_content_bottom() - child_widget.rect.h)
+
+
+class ConstraintAnchorTopRight(Constraint):
+    def __init__(self):
+        super().__init__(name="anchor_topright")
+        
+    def evaluate(self, parent_widget,child_widget):
+        return  child_widget.rect.topright == parent_widget.rect.topright
+        
+    def apply_constraint(self,parent_widget,child_widget):
+        if not self.evaluate(parent_widget,child_widget):
+            child_widget.set_position(parent_widget.get_content_right()-child_widget.rect.w, parent_widget.get_content_top())
+
+
+
+