batframework 1.0.8a2__py3-none-any.whl → 1.0.8a4__py3-none-any.whl

batFramework/gui/container.py

@@ -1,49 +1,191 @@
 import batFramework as bf
 from .widget import Widget
-from .layout import Layout
-from .constraints import Constraint
+from .shape import Shape
+from .interactiveWidget import InteractiveWidget
+from .layout import Layout, Column
 from typing import Self
+import pygame
+from pygame.math import Vector2
 
-class Container(Widget):
-    def __init__(self, layout:Layout=None, *children:Widget):
+
+class Container(Shape, InteractiveWidget):
+    def __init__(self, layout: Layout = None, *children: Widget) -> None:
         super().__init__()
+        self.dirty_children = False
         self.set_debug_color("green")
-        self.surface = None
-        self.layout :Layout = layout
-        if self.layout : self.layout.set_parent(self)
-        for child in children:
-            self.add_child(child)
+        self.layout: Layout = layout
+        self.scroll = Vector2(0, 0)
+        if not self.layout:
+            self.layout = Column()
+        self.layout.set_parent(self)
+        self.add(*children)
+
+    def __str__(self) -> str:
+        return f"Container({self.uid},{len(self.children)})"
+
+    def get_min_required_size(self):
+        if self.layout:
+            return self.layout.get_auto_size()
+        return self.rect.size
+
+    def reset_scroll(self) -> Self:
+        self.scroll.update(0, 0)
+        self.dirty_children = True
+        return self
+
+    def set_scroll(self, value: tuple) -> Self:
+        self.scroll.update(value)
+        self.dirty_children = True
+        return self
+
+    def scrollX_by(self, x: float | int) -> Self:
+        self.scroll.x += x
+        self.dirty_children = True
+        return self
+
+    def scrollY_by(self, y: float | int) -> Self:
+        self.scroll.y += y
+        self.dirty_children = True
+        return self
+
+    def scroll_by(self, value: tuple[float | int, float | int]) -> Self:
+        self.scroll += value
+        self.dirty_children = True
+        return self
+
+    def clamp_scroll(self) -> Self:
+        if not self.children:
+            return Self
+        r = self.get_padded_rect()
+        size = self.children[0].rect.unionall(self.children[1:]).size
+
+        # Calculate the maximum scroll values
+        max_scroll_x = max(0, size[0] - r.width)
+        max_scroll_y = max(0, size[1] - r.height)
+
+        # Clamp the scroll values
+        self.scroll.x = max(0, min(self.scroll.x, max_scroll_x))
+        self.scroll.y = max(0, min(self.scroll.y, max_scroll_y))
 
-    def set_layout(self,layout:Layout)->Self:
+        self.dirty_children = True
+        return self
+
+    def set_layout(self, layout: Layout) -> Self:
+        tmp = self.layout
         self.layout = layout
-        self.apply_constraints()
+        if self.layout != tmp:
+            self.dirty_children = True
         return self
 
-    def get_bounding_box(self):
-        yield (self.rect,self._debug_color)
-        for child in self.children:
-            yield from child.get_bounding_box()
+    def get_interactive_children(self) -> list[InteractiveWidget]:
+        return [
+            child
+            for child in self.children
+            if isinstance(child, InteractiveWidget) and child.allow_focus_to_self()
+        ]
+
+    def focus_next_child(self) -> None:
+        self.layout.focus_next_child()
+
+    def focus_prev_child(self) -> None:
+        self.layout.focus_prev_child()
 
-    def clear_children(self)->None:
+    def clear_children(self) -> None:
         self.children.clear()
-        self.apply_constraints()
+        self.dirty_children = True
+
+    def add(self, *child: Widget) -> Self:
+        super().add(*child)
+        self.dirty_children = True
+        return self
+
+    def remove(self, *child: Widget) -> Self:
+        super().remove(*child)
+        self.dirty_children = True
+        return self
+
+    def resolve_constraints(self) -> None:
+        super().resolve_constraints()
+
+    def top_at(self, x: float | int, y: float | int) -> "None|Widget":
+        if self.visible and self.rect.collidepoint(x, y):
+            if self.children:
+                for child in reversed(self.children):
+                    r = child.top_at(x, y)
+                    if r is not None:
+                        return r
+            return self
+        return None
+
+    def get_focus(self) -> bool:
+        res = super().get_focus()
+        if not res:
+            return False
+        l = l = self.get_interactive_children()
+        if not l:
+            return True
+        self.focused_index = min(self.focused_index, len(l))
+        return l[self.focused_index].get_focus()
+
+    def do_handle_event(self, event):
+        self.layout.handle_event(event)
+
+    def set_focused_child(self, child: InteractiveWidget) -> bool:
+        l = self.get_interactive_children()
+        try:
+            i = l.index(child)
+        except ValueError:
+            return False
+        if i >= 0:
+            self.focused_index = i
+            return True
+        return False
+
+    def allow_focus_to_self(self) -> bool:
+        return len(self.get_interactive_children()) != 0 and self.visible
+
+    def draw(self, camera: bf.Camera) -> None:
+        constraints_down = False
+        if self.dirty_shape:
+            self.dirty_constraints = True
+            self.dirty_children = True
+            self.dirty_surface = True
+            self.build()
+            for child in self.children:
+                child.dirty_constraints = True
+            self.dirty_shape = False
+
+        if self.dirty_constraints:
+            if self.parent and self.parent.dirty_constraints:
+                self.parent.visit_up(self.selective_up)
+            else:
+                constraints_down = True
+        if not self.dirty_children:
+            self.dirty_children = any(c.dirty_shape for c in self.children)
+        if self.dirty_children:
+            if self.layout:
+                self.layout.arrange()
+            self.dirty_children = False
 
-    def add_child(self,*child:Widget)->None:
-        super().add_child(*child)
-        if self.layout : self.layout.arrange()
+        if constraints_down:
+            self.visit(lambda c: c.resolve_constraints())
 
-    def remove_child(self,child:Widget)->None:
-        super().remove_child(child)
-        if self.layout : self.layout.arrange()
+        if self.dirty_surface:
+            self.paint()
+            self.dirty_surface = False
 
-    def build(self)->None:
-        super().build()
-        if self.layout : self.layout.arrange()
+        bf.Entity.draw(self, camera)
 
-    def apply_constraints(self)->None:
-        super().apply_constraints()
-        if self.layout : self.layout.arrange()
+        if self.clip_children:
+            new_clip = camera.world_to_screen(self.get_padded_rect())
+            old_clip = camera.surface.get_clip()
+            new_clip = new_clip.clip(old_clip)
+            camera.surface.set_clip(new_clip)
+        # Draw children with adjusted positions
+        _ = [
+            child.draw(camera)
+            for child in sorted(self.children, key=lambda c: c.render_order)
+        ]
 
-    def to_string_id(self)->str:
-        return f"Container({len(self.children)},{[c.to_string() for c in self.constraints]})"
-    
+        if self.clip_children:
+            camera.surface.set_clip(old_clip)

batFramework/gui/debugger.py

@@ -1,47 +1,135 @@
 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 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()
+    def __init__(self) -> None:
+        super().__init__("")
+        self.static_data: dict = {}
+        self.dynamic_data: dict = {}
+        self.refresh_rate = 10
+        self.refresh_counter: float = 0
+        self.add_tags("debugger")
+        self.set_visible(False)
+
+    def set_refresh_rate(self, value: int) -> Self:
+        self.refresh_rate = value
+        return self
+
+    def add_static(self, key: str, data):
+        self.static_data[key] = str(data)
+        self.update_text()
+
+    def add_dynamic(self, key: str, func) -> None:
+        self.dynamic_data[key] = func
+        self.update_text()
+
+    def remove_static(self, key) -> bool:
+        try:
+            self.static_data.pop(key)
+            return True
+        except KeyError:
+            return False
+
+    def remove_dynamic(self, key) -> bool:
+        try:
+            self.dynamic_data.pop(key)
+            return True
+        except KeyError:
+            return False
+
+    def set_parent_scene(self, scene) -> Self:
+        super().set_parent_scene(scene)
+        self.set_render_order(99)
+        self.update_text()
+        return self
+
+    def set_text(self, text: str) -> Self:
+        return super().set_text(text)
+
+    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("debug_mode") != bf.debugMode.DEBUGGER:
+            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()
+
+    def __str__(self) -> str:
+        return "Debugger"
+
+    def top_at(self, x, y):
+        return None
+
+
+class FPSDebugger(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
+        self.add_dynamic("FPS", lambda: str(round(manager_link.get_fps())))
+
+
+class BasicDebugger(FPSDebugger):
+    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
+        self.add_dynamic(
+            "Resolution", lambda: "x".join(str(i) for i in bf.const.RESOLUTION)
+        )
+        super().do_when_added()
+        parent_scene = self.parent_scene
+
+        self.add_dynamic("Mouse", pygame.mouse.get_pos)
+        self.add_dynamic(
+            "World",
+            lambda: convert_to_int(
+                *parent_scene.camera.screen_to_world(pygame.mouse.get_pos())
+            ),
+        )
+        self.add_dynamic(
+            "Hud",
+            lambda: convert_to_int(
+                *parent_scene.hud_camera.screen_to_world(pygame.mouse.get_pos())
+            ),
+        )
+        self.add_dynamic("W. Ent.", lambda: parent_scene.get_world_entity_count())
+        self.add_dynamic("H. Ent.", lambda: parent_scene.get_hud_entity_count())
+
+        self.add_dynamic(
+            "Hover",
+            lambda: (
+                str(parent_scene.root.hovered) if parent_scene.root.hovered else None
+            ),
+        )

batFramework/gui/dialogueBox.py

@@ -0,0 +1,99 @@
+from .label import Label
+import batFramework as bf
+from typing import Self
+
+
+class DialogueBox(Label):
+    def __init__(self) -> None:
+        self.cursor_position: float = 0.0
+        self.text_speed: float = 20.0
+        self.message_queue: list[str] = []
+        self.is_over: bool = True
+        self.is_paused: bool = False
+        self.set_autoresize(False)
+        self.set_alignment(bf.alignment.LEFT)
+        super().__init__("")
+
+    def __str__(self) -> str:
+        return "DialogueBox"
+
+    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_padded_width()
+        if text == "" or not self.font_object or w < self.font_object.point_size:
+            return [text]
+        left = 0
+        for index in range(len(text)):
+            width = self.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 paint(self) -> None:
+        if self.font_object and self.message_queue:
+            message = self.message_queue.pop(0)
+            message = "\n".join(self.cut_text_to_width(message))
+            self.message_queue.insert(0, message)
+        super().paint()
+
+    def say(self, message: str) -> Self:
+        self.message_queue.append(message)
+        self.is_over = False
+        return self
+
+    def is_queue_empty(self) -> bool:
+        return not self.message_queue
+
+    def is_current_message_over(self) -> bool:
+        return self.is_over
+
+    def clear_queue(self) -> Self:
+        self.message_queue.clear()
+        self.next_message()
+        return self
+
+    def next_message(self) -> Self:
+        if self.message_queue:
+            self.message_queue.pop(0)
+        self.cursor_position = 0
+        self.set_text("")
+        return self
+
+    def skip_current_message(self) -> Self:
+        self.cursor_position = len(self.message_queue[0])
+        self.dirty_shape = True
+
+    def do_update(self, dt):
+        if not self.message_queue or self.is_paused:
+            return
+        if not self.is_over and self.cursor_position == len(self.message_queue[0]):
+            self.is_over = True
+            return
+        self.cursor_position = min(
+            self.cursor_position + self.text_speed * dt, len(self.message_queue[0])
+        )
+        self.set_text(self.message_queue[0][: int(self.cursor_position)])

batFramework/gui/draggableWidget.py

@@ -0,0 +1,40 @@
+from .interactiveWidget import InteractiveWidget
+import batFramework as bf
+import pygame
+
+
+class DraggableWidget(InteractiveWidget):
+    def __init__(self, *args, **kwargs) -> None:
+        self.drag_action = bf.Action("dragging").add_mouse_control(1).set_holding()
+
+        self.drag_start = None
+        self.offset = None
+        super().__init__(*args, **kwargs)
+
+    def do_process_actions(self, event: pygame.Event) -> None:
+        self.drag_action.process_event(event)
+
+    def do_reset_actions(self) -> None:
+        self.drag_action.reset()
+
+    def do_on_drag(
+        self, drag_start: tuple[float, float], drag_end: tuple[float, float]
+    ) -> None:
+        self.set_position(drag_end[0] - self.offset[0], drag_end[1] - self.offset[1])
+
+    def update(self, dt: float):
+        if self.drag_action.active and self.is_clicked_down:
+            r = self.get_root()
+            x, y = r.drawing_camera.screen_to_world(pygame.mouse.get_pos())
+            if self.drag_start == None and self.drag_action.active:
+                self.offset = x - self.rect.x, y - self.rect.y
+                self.drag_start = x, y
+                return
+            else:
+                self.do_on_drag(self.drag_start, (x, y))
+                return
+        else:
+            self.drag_start = None
+            self.offset = None
+            self.is_clicked_down = False
+        super().update(dt)

batFramework/gui/image.py

@@ -1,23 +1,59 @@
 import batFramework as bf
 from .widget import Widget
+from .shape import Shape
 import pygame
-class Image(Widget):
-	def __init__(self,data:pygame.Surface|str,size:None|tuple[int,int]=None,convert_alpha=True):
-		super().__init__(False)
-		self.surface = None
-		if isinstance(data,str):
-			path = bf.utils.get_path(data)
-			self.original_surface=pygame.image.load(path)
-		elif isinstance(data,pygame.Surface):
-			self.original_surface = data
-			
-		if convert_alpha:	self.original_surface = self.original_surface.convert_alpha()
-		if not size : size = self.original_surface.get_size()
-		self.set_size(*size)
+from typing import Self
 
 
-	def build(self)->None:
-		if not self.surface or self.surface.get_size() != self.get_size_int():
-			self.surface = pygame.transform.scale(self.original_surface,self.get_size_int())
-			
-            
+class Image(Shape):
+    def __init__(
+        self,
+        path: str = None,
+        convert_alpha=True,
+    ):
+        self.original_surface = None
+        super().__init__(convert_alpha=convert_alpha)
+        if path is not None:
+            self.from_path(path)
+
+    def __str__(self) -> str:
+        return "Image"
+
+    def paint(self) -> None:
+        super().paint()
+        # self.surface.fill((0,0,0,0 if self.convert_alpha else 255))
+        if self.original_surface is None:
+            return
+        if self.rect.size != self.original_surface.get_size():
+            self.surface.blit(
+                pygame.transform.scale(self.original_surface, self.rect.size), (0, 0)
+            )
+        else:
+            self.surface.blit(self.original_surface, (0, 0))
+
+    def from_path(self, path: str) -> Self:
+        tmp = bf.ResourceManager().get_image(path, self.convert_alpha)
+        if tmp is None:
+            return self
+        self.original_surface = tmp
+        size = self.original_surface.get_size()
+        if not self.autoresize_h:
+            size[0] = None
+        if not self.autoresize_h:
+            size[1] = None
+        self.set_size(size)
+        self.dirty_surface = True
+        return self
+
+    def from_surface(self, surface: pygame.Surface) -> Self:
+        if surface is None:
+            return self
+        self.original_surface = surface
+        size = self.original_surface.get_size()
+        if not self.autoresize_h:
+            size[0] = None
+        if not self.autoresize_h:
+            size[1] = None
+        self.set_size(size)
+        self.dirty_surface = True
+        return self