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

batFramework/gui/constraints.py

@@ -1,43 +1,29 @@
 from .widget import Widget
 import batFramework as bf
 
-
 class Constraint:
-    def __init__(self,name="Constraint", priority=0):
+    def __init__(self, name="Constraint", priority=0):
         self.priority = priority
         self.name = name
-    def set_priority(self, priority)->"Constraint":
+
+    def set_priority(self, priority) -> "Constraint":
         self.priority = priority
         return self
-    def to_string(self)->str:
+
+    def to_string(self) -> str:
         return f"{self.name.upper()}"
-        
-    def evaluate(self, parent_widget:Widget, child_widget:Widget) -> bool:
+
+    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:
+    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")
-
-
-
-
-
-
-
-
-
-
-
-
-
-
 
+    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):
@@ -49,11 +35,9 @@ class ConstraintMinWidth(Constraint):
 
     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)
+            child_widget.set_size(self.min_width, child_widget.rect.h)
 
 
-            
-    
 class ConstraintCenterX(Constraint):
     def __init__(self):
         super().__init__(name="centerx")
@@ -61,9 +45,12 @@ class ConstraintCenterX(Constraint):
     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)
+    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):
@@ -72,9 +59,12 @@ class ConstraintCenterY(Constraint):
     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])
+    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):
@@ -83,147 +73,190 @@ class ConstraintCenter(Constraint):
     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):
+    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):
+    def __init__(self, percentage: float, keep_autoresize: bool = True):
         super().__init__(name="percentage_width")
-        self.percentage:float = percentage
+        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 to_string(self) -> str:
+        return f"{super().to_string()}.[{self.percentage*100}%,keep_autoresize={self.keep_autoresize}]"
+
     def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.width == round(parent_widget.get_content_width() * self.percentage)
+        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):
+    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 
+                    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)
+            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):
+    def __init__(self, percentage: float, keep_autoresize: bool = True):
         super().__init__(name="percentage_height")
-        self.percentage:float = percentage
+        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)
+        return child_widget.rect.height == round(
+            parent_widget.get_content_height() * self.percentage
+        )
+        
+    def to_string(self) -> str:
+        return f"{super().to_string()}.[{self.percentage*100}%,keep_autoresize={self.keep_autoresize}]"
 
-    def apply_constraint(self,parent_widget,child_widget):
-        if not self.evaluate(parent_widget,child_widget):
+    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 
+                    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))
+            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 :
+    def __init__(self, height: float, keep_autoresize: bool = True):
+        if height < 0:
             raise ValueError("height can't be negative")
         super().__init__(name="height")
         self.height = height
+        self.keep_autoresize:bool = keep_autoresize
 
-    def to_string(self)->str:
-        return f"{super().to_string()}.({self.height})"
+    def to_string(self) -> str:
+        return f"{super().to_string()}.(height={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)
+    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, self.height)
+
 
 class ConstraintWidth(Constraint):
-    def __init__(self,width:float):
-        if width < 0 :
+    def __init__(self, width: float, keep_autoresize: bool = True):
+        if width < 0:
             raise ValueError("width can't be negative")
         super().__init__(name="width")
         self.width = width
+        self.keep_autoresize : bool = keep_autoresize
 
-    def to_string(self)->str:
-        return f"{super().to_string()}.({self.width})"
+    def to_string(self) -> str:
+        return f"{super().to_string()}.(width={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)
+    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(self.width, child_widget.rect.h)
 
 
 class ConstraintAspectRatio(Constraint):
-    def __init__(self,ratio:int|float=1):
+    def __init__(self, ratio: int | float = 1):
         super().__init__(name="aspect_ratio")
-        if isinstance(ratio, float|int):
+        if isinstance(ratio, float | int):
             self.ratio = ratio
-        elif isinstance(ratio,Widget):
+        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
-    
+
+    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.get_content_bottom()
-        
-    def apply_constraint(self,parent_widget,child_widget):
-        if not self.evaluate(parent_widget,child_widget):
+
+    def evaluate(self, parent_widget, child_widget):
+        return child_widget.rect.bottom == parent_widget.get_content_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.get_content_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())
 
+    def evaluate(self, parent_widget, child_widget):
+        return child_widget.rect.topright == parent_widget.get_content_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(),
+            )
 
 
 class ConstraintAnchorRight(Constraint):
     def __init__(self):
         super().__init__(name="anchor_right")
-        
-    def evaluate(self, parent_widget,child_widget):
-        return  child_widget.rect.right == parent_widget.get_content_right()
-        
-    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, child_widget.rect.top)
 
+    def evaluate(self, parent_widget, child_widget):
+        return child_widget.rect.right == parent_widget.get_content_right()
 
+    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,
+                child_widget.rect.top,
+            )
 
 
 class ConstraintAnchorLeft(Constraint):
     def __init__(self):
         super().__init__(name="anchor_left")
-        
-    def evaluate(self, parent_widget,child_widget):
-        return  child_widget.rect.left == parent_widget.get_content_left()
-        
-    def apply_constraint(self,parent_widget,child_widget):
-        if not self.evaluate(parent_widget,child_widget):
-            child_widget.set_position(parent_widget.get_content_left(), child_widget.rect.top)
 
+    def evaluate(self, parent_widget, child_widget):
+        return child_widget.rect.left == parent_widget.get_content_left()
 
+    def apply_constraint(self, parent_widget, child_widget):
+        if not self.evaluate(parent_widget, child_widget):
+            child_widget.set_position(
+                parent_widget.get_content_left(), child_widget.rect.top
+            )

batFramework/gui/container.py

@@ -1,61 +1,60 @@
 import batFramework as bf
 from .widget import Widget
-from .layout import Layout
+from .layout import Layout,Column
 from .constraints import Constraint
 from typing import Self
 
 class Container(Widget):
-    def __init__(self, layout:Layout=None, *children:Widget):
+    def __init__(self, layout: Layout = Column(), *children: Widget)->None:
         super().__init__()
         self.set_debug_color("green")
         self.surface = None
-        self.layout :Layout = layout
-        if self.layout : self.layout.set_parent(self)
+        self.layout: Layout = layout
+        if self.layout:
+            self.layout.set_parent(self)
         for child in children:
             self.add_child(child)
 
-    def set_layout(self,layout:Layout)->Self:
+    def set_padding(self,value)->Self:
+        return self
+
+    def set_layout(self, layout: Layout) -> Self:
         self.layout = layout
         self.apply_constraints()
         return self
 
     def get_bounding_box(self):
-        yield (self.rect,self._debug_color)
+        yield (self.rect, self.debug_color)
         for child in self.children:
             yield from child.get_bounding_box()
 
-    def clear_children(self)->None:
+    def clear_children(self) -> None:
         self.children.clear()
         self.apply_constraints()
 
-    def add_child(self,*child:Widget)->None:
+    def add_child(self, *child: Widget) -> None:
         super().add_child(*child)
-        if self.layout : self.layout.arrange()
+        if self.layout:
+            self.layout.arrange()
 
-    def remove_child(self,child:Widget)->None:
+    def remove_child(self, child: Widget) -> None:
         super().remove_child(child)
-        if self.layout : self.layout.arrange()
+        if self.layout:
+            self.layout.arrange()
 
-    def build(self)->None:
+    def build(self) -> None:
         super().build()
-        if self.layout : self.layout.arrange()
+        if self.layout:
+            self.layout.arrange()
 
-    def apply_constraints(self)->None:
+    def apply_constraints(self) -> None:
         super().apply_constraints()
-        if self.layout : self.layout.arrange()
-
-    def to_string_id(self)->str:
-        return f"Container({len(self.children)},{[c.to_string() for c in self.constraints]})"
-    
-    def children_modified(self)->None:
+        if self.layout:
+            self.layout.arrange()
 
-        self.build_all()
-        self.set_size(
-            # *self.inflate_rect_by_padding(self.rect.unionall(list(c.rect for c in self.children))).size
-            *self.rect.unionall(list(c.rect for c in self.children)).size
-        )
+    def to_string_id(self) -> str:
+        return f"Container({self.uid},{len(self.children)},{[c.to_string() for c in self.constraints]})"
 
-        self.apply_constraints()
-        
+    def children_modified(self)->None:
+        self.apply_all_constraints()
         super().children_modified()
-        

batFramework/gui/debugger.py

@@ -1,47 +1,97 @@
 from .label import Label
 from typing import Self
+import batFramework as bf
+import pygame
+
+
+def convert_to_int(*args):
+    return [int(arg) for arg in args]
+
+
 
 class Debugger(Label):
-	def __init__(self)->None:
-		super().__init__("")
-		self.static_data : dict 	= {}
-		self.dynamic_data : dict 	= {}
-		self.refresh_rate = 10
-		self.refresh_counter = 0
-		self.render_order = 99
-
-	def to_string_id(self)->str:
-		return "Debugger"
-		
-	def set_refresh_rate(self, value:int)-> Self:
-		self.refresh_rate = value
-		return self
-		
-	def add_data(self,key:str,data):
-		self.static_data[key] = str(data)
-		self.update_text()
-		
-	def add_dynamic_data(self,key:str,func)->None:
-		self.dynamic_data[key] = func
-		self.update_text()
-
-	def set_parent_scene(self,scene)->None:
-	    super().set_parent_scene(scene)
-	    self.update_text()
+    def __init__(self) -> None:
+        super().__init__("")
+        self.static_data: dict = {}
+        self.dynamic_data: dict = {}
+        self.refresh_rate = 10
+        self.refresh_counter : float = 0
+        self.render_order = 99
+        self.set_uid("debugger")
+
+    def to_string_id(self) -> str:
+        return "Debugger"
+
+    def set_refresh_rate(self, value: int) -> Self:
+        self.refresh_rate = value
+        return self
+
+    def add_data(self, key: str, data):
+        self.static_data[key] = str(data)
+        self.update_text()
+
+    def add_dynamic_data(self, key: str, func) -> None:
+        self.dynamic_data[key] = func
+        self.update_text()
+
+    def set_parent_scene(self, scene) -> Self:
+        super().set_parent_scene(scene)
+        self.update_text()
+        return self
+
+    def update_text(self) -> None:
+        if not self.parent_scene:
+            return
+        d = "\n".join(
+            key + ":" + data if key != "" else data
+            for key, data in self.static_data.items()
+        )
+        d2 = "\n".join(
+            key + ":" + str(data()) if key != "" else str(data())
+            for key, data in self.dynamic_data.items()
+        )
+        self.set_text("\n".join((d, d2)).strip())
+
+    def update(self, dt: float) -> None:
+        if not self.parent_scene:
+            return
+        if self.parent_scene.get_sharedVar("debugging_mode") != 1:
+            self.set_visible(False)
+            return
+        self.set_visible(True)
+        self.refresh_counter = self.refresh_counter + (dt * 60)
+        if self.refresh_counter > self.refresh_rate:
+            self.refresh_counter = 0
+            self.update_text()
+
+
+class BasicDebugger(Debugger):
+    def __init__(self):
+        super().__init__()
+
+    def do_when_added(self):
+        if not self.parent_scene or  not self.parent_scene.manager:
+            print("Debugger could not link to the manager")
+            return
+        manager_link = self.parent_scene.manager
+        parent_scene = self.parent_scene
+        self.add_data("Resolution", 'x'.join(str(i) for i in bf.const.RESOLUTION))
+        self.add_dynamic_data(
+            "FPS", lambda: str(round(manager_link.get_fps()))
+        )
+        self.add_dynamic_data("Mouse", pygame.mouse.get_pos)
+        self.add_dynamic_data(
+            "World",
+            lambda: convert_to_int(*parent_scene.camera.convert_screen_to_world(
+                *pygame.mouse.get_pos())
+            ),
+        )
+        self.add_dynamic_data(
+            "Hud",
+            lambda: convert_to_int(*parent_scene.hud_camera.convert_screen_to_world(
+                *pygame.mouse.get_pos())
+            ),
+        )
+        self.add_dynamic_data("W. Ent.",lambda : parent_scene.get_world_entity_count())
+        self.add_dynamic_data("H. Ent.",lambda : parent_scene.get_hud_entity_count())
         
-	def update_text(self)->None:
-		if not self.parent_scene:return	
-		d = '\n'.join(key+':'+data if key!='' else data for key,data in self.static_data.items())
-		d2 = '\n'.join(key+':'+str(data()) if key!='' else str(data()) for key,data in self.dynamic_data.items())
-		self.set_text('\n'.join((d,d2)).strip())
-
-	def update(self,dt:float)->None:
-		if not self.parent_scene:return
-		if self.parent_scene.get_sharedVar("is_debugging_func")() != 1:
-			self.set_visible(False)
-			return
-		self.set_visible(True)
-		self.refresh_counter = self.refresh_counter + (dt * 60) 
-		if self.refresh_counter > self.refresh_rate:
-			self.refresh_counter = 0
-			self.update_text()

batFramework/gui/frame.py

@@ -4,22 +4,22 @@ import pygame
 
 
 class Frame(Shape):
-    def __init__(self,width:float,height:float):
-        super().__init__(width,height)
+    def __init__(self, width: float, height: float,fit_to_children:bool=True):
+        self.fit_to_children = fit_to_children
+        super().__init__(width, height)
         self.set_debug_color("magenta")
-
-    def to_string_id(self)->str:
+    def to_string_id(self) -> str:
         return "Frame"
-    
-    def children_modified(self)->None:
+
+    def _fit_to_children(self)->None:
         # TODO CLEAN THIS UP
-        if not self.children : return
-        self.build_all()
-        self.set_size(
-            # *self.inflate_rect_by_padding(self.rect.unionall(list(c.rect for c in self.children))).size
-            *self.inflate_rect_by_padding(self.children[0].rect.unionall(list(c.rect for c in self.children))).size
-        )
-        for c in self.children : 
-            c.set_position(*c.rect.clamp(self.get_content_rect()).topleft)
-        self.apply_constraints()
+        if not self.children: return
+        children_rect = self.children[0].rect.unionall(list(c.rect for c in self.children))
+        self.set_size(*self.inflate_rect_by_padding(children_rect).size)
+        self.rect.center = children_rect.center
+        self.apply_all_constraints()
+        
+    def children_modified(self) -> None:
         super().children_modified()
+        if self.fit_to_children:
+            self._fit_to_children()