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

batFramework/gui/interactiveWidget.py

@@ -181,6 +181,6 @@ class InteractiveWidget(Widget):
         pygame.draw.rect(
             camera.surface,
             "white",
-            self.rect.move(-camera.rect.x, -camera.rect.y).inflate(delta, delta),
+            self.rect.move(-camera.rect.x, -camera.rect.y),#.inflate(delta, delta),
             1,
         )

batFramework/gui/label.py

@@ -101,6 +101,12 @@ class Label(Shape):
         self.dirty_surface = True
         return self
 
+    def set_text_outline_mask_size(self,size:tuple[int,int])->Self:
+        old_size = self._text_outline_mask.get_size()
+        m = [[self._text_outline_mask.get_at((x,y)) for x in range(min(old_size[0],size[0]))] for y in range(min(old_size[1],size[1]))]
+        self._text_outline_mask = pygame.Mask(size, fill=True)
+        self.set_text_outline_matrix(m)
+
     def set_text_outline_matrix(self, matrix: list[list[0 | 1]]) -> Self:
         if matrix is None:
             matrix = [[0 for _ in range(3)] for _ in range(3)]
@@ -125,12 +131,12 @@ class Label(Shape):
         self.dirty_surface = True
         return self
 
-    def set_alignment(self, alignment: bf.alignment) -> "Label":
+    def set_alignment(self, alignment: bf.alignment) -> Self:
         self.alignment = alignment
         self.dirty_surface = True
         return self
 
-    def set_auto_wraplength(self, val: bool) -> "Label":
+    def set_auto_wraplength(self, val: bool) -> Self:
         self.auto_wraplength = val
         if self.autoresize_h or self.autoresize_w:
             self.dirty_shape = True
@@ -186,18 +192,7 @@ class Label(Shape):
         if not (self.autoresize_w or self.autoresize_h):
             return self.rect.size
         if not self.text_rect:
-            params = {
-                "font_name": self.font_object.name,
-                "text": self.text,
-                "antialias": False,
-                "color": "white",
-                "bgcolor": "black",  # if (self.has_alpha_color() or self.draw_mode == bf.drawMode.TEXTURED) else self.color,
-                "wraplength": (
-                    int(self.get_padded_width()) if self.auto_wraplength else 0
-                ),
-            }
-
-            self.text_rect.size = self._render_font(params).get_size()
+            self.text_rect.size = self._get_text_rect_required_size()
         res = self.inflate_rect_by_padding((0, 0, *self.text_rect.size)).size
         # return res
         return res[0] if self.autoresize_w else self.rect.w, (
@@ -242,9 +237,7 @@ class Label(Shape):
             surf = self.font_object.render(**params)
 
         return surf
-
-    def _build_layout(self) -> None:
-
+    def _get_text_rect_required_size(self):
         params = {
             "font_name": self.font_object.name,
             "text": self.text,
@@ -254,7 +247,13 @@ class Label(Shape):
             "wraplength": int(self.get_padded_width()) if self.auto_wraplength else 0,
         }
 
-        self.text_rect.size = self._render_font(params).get_size()
+        size = self._render_font(params).get_size()
+        s = self._text_outline_mask.get_size()
+        return size[0] + s[0]//2, size[1] + s[1]//2
+    def _build_layout(self) -> None:
+
+        self.text_rect.size = self._get_text_rect_required_size()
+        
         if self.autoresize_h or self.autoresize_w:
             target_rect = self.inflate_rect_by_padding((0, 0, *self.text_rect.size))
             if not self.autoresize_w:
@@ -268,6 +267,10 @@ class Label(Shape):
         padded = self.get_padded_rect().move(-self.rect.x, -self.rect.y)
         self.align_text(self.text_rect, padded, self.alignment)
 
+    def _get_outline_offset(self)->tuple[int,int]:
+        mask_size = self._text_outline_mask.get_size()
+        return  mask_size[0]//2,mask_size[1]//2
+
     def _paint_text(self) -> None:
         if self.font_object is None:
             print(f"No font for widget with text : '{self}' :(")
@@ -291,15 +294,16 @@ class Label(Shape):
             )
 
         l = []
+        outline_offset = self._get_outline_offset()
         if self.show_text_outline:
             l.append(
                 (
                     self.text_outline_surface,
-                    self.text_rect.move(-1, self.relief - self.get_relief() - 1),
+                    self.text_rect.move(0, self.relief - self.get_relief()),
                 )
             )
         l.append(
-            (self.text_surface, self.text_rect.move(0, self.relief - self.get_relief()))
+            (self.text_surface, self.text_rect.move(outline_offset[0], self.relief - self.get_relief() + outline_offset[1]))
         )
         self.surface.fblits(l)
 

batFramework/gui/root.py

@@ -95,6 +95,8 @@ class Root(InteractiveWidget):
         return self
 
     def do_handle_event(self, event):
+        if not self.parent_scene.get_sharedVar("player_has_control"):
+            return
         if self.focused:
             if event.type == pygame.KEYDOWN:
                 if self.focused.on_key_down(event.key):
@@ -128,6 +130,8 @@ class Root(InteractiveWidget):
 
     def update(self, dt: float) -> None:
         super().update(dt)
+        if not self.parent_scene.get_sharedVar("player_has_control",True):
+            return
         old = self.hovered
         transposed = self.drawing_camera.screen_to_world(pygame.mouse.get_pos())
         self.hovered = self.top_at(*transposed) if self.top_at(*transposed) else None
@@ -139,8 +143,10 @@ class Root(InteractiveWidget):
         if self.hovered and isinstance(self.hovered, InteractiveWidget):
             self.hovered.on_enter()
 
-    def draw(self, camera: bf.Camera) -> int:
+    def draw(self, camera: bf.Camera) -> None:
         super().draw(camera)
+        if not self.parent_scene.get_sharedVar("player_has_control"):
+            return
         if (
             self.parent_scene
             and self.parent_scene.active

batFramework/gui/shape.py

@@ -10,7 +10,7 @@ class Shape(Widget):
         super().__init__(size=size, convert_alpha=True)
         self.color = (0, 0, 0, 0)
         self.border_radius: list[int] = [0]
-        self.outline: int = 0
+        self.outline_width: int = 0
         self.outline_color: tuple[int, int, int] | str = (0, 0, 0, 255)
         self.texture_surface = None
         self.texture_subsize = (0, 0)
@@ -97,7 +97,7 @@ class Shape(Widget):
         return self
 
     def set_outline_width(self, value: int) -> Self:
-        self.outline = value
+        self.outline_width = value
         self.dirty_surface = True
         return self
 
@@ -107,11 +107,11 @@ class Shape(Widget):
             return
         if self.border_radius == [0]:
             self._paint_shape()
-            if self.outline:
+            if self.outline_width:
                 self._paint_outline()
         else:
             self._paint_rounded_shape()
-            if self.outline:
+            if self.outline_width:
                 self._paint_rounded_outline()
 
     def _paint_textured(self) -> None:
@@ -223,17 +223,23 @@ class Shape(Widget):
         return pygame.FRect(0, self.rect.h - self.relief, self.rect.w, self.relief)
 
     def _paint_shape(self) -> None:
-        self.surface.fill((0, 0, 0, 0))
-        self.surface.fill(self.shadow_color, self._get_base_rect())
-        self.surface.fill(self.color, self._get_elevated_rect())
+        if self.relief!=0:
+            self.surface.fill((0, 0, 0, 0))
+            self.surface.fill(self.shadow_color, self._get_base_rect())
+            self.surface.fill(self.color, self._get_elevated_rect())
+        else:
+            self.surface.fill(self.color, self._get_elevated_rect())
 
     def _paint_rounded_shape(self) -> None:
         self.surface.fill((0, 0, 0, 0))
         e = self._get_elevated_rect()
-        b = e.copy()
-        b.bottom = self.rect.h
-        pygame.draw.rect(self.surface, self.shadow_color, b, 0, *self.border_radius)
-        pygame.draw.rect(self.surface, self.color, e, 0, *self.border_radius)
+        if self.relief != 0:
+            b = e.copy()
+            b.bottom = self.rect.h
+            pygame.draw.rect(self.surface, self.shadow_color, b, 0, *self.border_radius)
+            pygame.draw.rect(self.surface, self.color, e, 0, *self.border_radius)
+        else:
+            pygame.draw.rect(self.surface, self.color, e, 0, *self.border_radius)
 
     def _paint_outline(self) -> None:
         if self.relief:
@@ -246,7 +252,7 @@ class Shape(Widget):
                     self.rect.w,
                     self.rect.h - self.relief,
                 ),
-                self.outline,
+                self.outline_width,
             )
         pygame.draw.rect(
             self.surface,
@@ -257,7 +263,7 @@ class Shape(Widget):
                 self.rect.w,
                 self.rect.h - (self.relief - self.get_relief()),
             ),
-            self.outline,
+            self.outline_width,
         )
 
     def _paint_rounded_outline(self) -> None:
@@ -269,7 +275,7 @@ class Shape(Widget):
             self.surface,
             self.outline_color,
             e,
-            self.outline,
+            self.outline_width,
             *self.border_radius,
         )
         if self.relief:
@@ -277,6 +283,6 @@ class Shape(Widget):
                 self.surface,
                 self.outline_color,
                 b,
-                self.outline,
+                self.outline_width,
                 *self.border_radius,
             )

batFramework/gui/slider.py

@@ -11,6 +11,7 @@ class SliderHandle(Indicator, DraggableWidget):
     def __init__(self):
         super().__init__()
         self.set_color(bf.color.CLOUD_SHADE)
+        self.old_key_repeat: tuple = (0, 0)
 
     def __str__(self) -> str:
         return "SliderHandle"
@@ -68,8 +69,6 @@ class Slider(Button):
         self.add(self.meter, self.handle)
         self.meter.set_debug_color(bf.color.RED)
         self.set_value(default_value, True)
-        # print(self.handle.rect)
-        # self.handle.set_visible(False)
 
     def set_visible(self, value: bool) -> Self:
         self.handle.set_visible(value)
@@ -84,20 +83,19 @@ class Slider(Button):
         self.gap = value
         return self
 
+    def do_on_get_focus(self) -> None:
+        super().do_on_get_focus()
+        self.old_key_repeat = pygame.key.get_repeat()
+        pygame.key.set_repeat(200, 50)
+
+    def do_on_lose_focus(self) -> None:
+        super().do_on_lose_focus()
+        pygame.key.set_repeat(*self.old_key_repeat)
+
     def get_min_required_size(self) -> tuple[float, float]:
         gap = self.gap if self.text else 0
         if not self.text_rect:
-            params = {
-                "font_name": self.font_object.name,
-                "text": self.text,
-                "antialias": False,
-                "color": "white",
-                "bgcolor": "black",  # if (self.has_alpha_color() or self.draw_mode == bf.drawMode.TEXTURED) else self.color,
-                "wraplength": (
-                    int(self.get_padded_width()) if self.auto_wraplength else 0
-                ),
-            }
-            self.text_rect.size = self._render_font(params).get_size()
+            self.text_rect.size = self._get_text_rect_required_size()
         w, h = self.text_rect.size
         return self.inflate_rect_by_padding((0, 0, w + gap + self.meter.rect.w, h)).size
 
@@ -134,10 +132,8 @@ class Slider(Button):
     def do_on_key_down(self, key):
         if key == pygame.K_RIGHT:
             self.set_value(self.meter.get_value() + self.meter.step)
-            bf.AudioManager().play_sound(self.click_down_sound)
         elif key == pygame.K_LEFT:
             self.set_value(self.meter.get_value() - self.meter.step)
-            bf.AudioManager().play_sound(self.click_down_sound)
 
     def do_on_click_down(self, button) -> None:
         if button == 1:
@@ -151,8 +147,6 @@ class Slider(Button):
         value_range = self.meter.get_range()
         value = round(value / self.meter.step) * self.meter.step
         position_ratio = (value - self.meter.min_value) / value_range
-        # print(self.handle.rect)
-        # print(rect.left + (self.handle.rect.w/2) + position_ratio * (rect.width - self.handle.rect.w),self.handle.rect.w,self.rect.right)
         return (
             rect.left
             + (self.handle.rect.w / 2)
@@ -178,16 +172,7 @@ class Slider(Button):
 
         gap = self.gap if self.text else 0
 
-        params = {
-            "font_name": self.font_object.name,
-            "text": self.text,
-            "antialias": False,
-            "color": "white",
-            "bgcolor": "black",  # if (self.has_alpha_color() or self.draw_mode == bf.drawMode.TEXTURED) else self.color,
-            "wraplength": int(self.get_padded_width()) if self.auto_wraplength else 0,
-        }
-
-        self.text_rect.size = self._render_font(params).get_size()
+        self.text_rect.size = self._get_text_rect_required_size()
 
         meter_size = [self.text_rect.h * 10, self.font_object.point_size]
         if not self.autoresize_w:
@@ -209,20 +194,19 @@ class Slider(Button):
                 return
 
         # ------------------------------------ size is ok
-        padded = self.get_padded_rect().move(-self.rect.x, -self.rect.y)
+        padded_rect = self.get_padded_rect()
+        padded_relative = padded_rect.move(-self.rect.x, -self.rect.y)
 
-        self.meter.set_size_if_autoresize(meter_size)
-        handle_size = 2 * [self.meter.get_padded_height()]
 
-        self.handle.set_size_if_autoresize(handle_size)
+        self.meter.set_size_if_autoresize(meter_size)
 
-        self.align_text(tmp_rect, padded, self.alignment)
+        self.align_text(tmp_rect, padded_relative, self.alignment)
         self.text_rect.midleft = tmp_rect.midleft
 
         if self.text:
             match self.spacing:
                 case bf.spacing.MAX:
-                    gap = padded.w - self.text_rect.w - self.meter.rect.w
+                    gap = padded_relative.right - self.text_rect.right - self.meter.rect.w
                 case bf.spacing.MIN:
                     gap = 0
 

batFramework/gui/textInput.py

@@ -42,10 +42,10 @@ class TextInput(Label, InteractiveWidget):
         pygame.mouse.set_cursor(bf.const.DEFAULT_CURSOR)
 
     def do_on_get_focus(self):
-        self.old_key_repeat = pygame.key.get_repeat()
         self.cursor_timer.resume()
         self._cursor_toggle(True)
         self.set_cursor_position(len(self.get_text()))
+        self.old_key_repeat = pygame.key.get_repeat()
         pygame.key.set_repeat(200, 50)
 
     def do_on_lose_focus(self):

batFramework/gui/toggle.py

@@ -13,6 +13,7 @@ class Toggle(Button):
         self.spacing: bf.spacing = bf.spacing.MANUAL
         super().__init__(text, callback)
         self.add(self.indicator)
+        self.set_clip_children(False)
         # self.set_gap(int(max(4, self.get_padded_width() / 3)))
 
     def set_visible(self, value: bool) -> Self:
@@ -53,24 +54,16 @@ class Toggle(Button):
 
     def get_min_required_size(self) -> tuple[float, float]:
         if not self.text_rect:
-            params = {
-                "font_name": self.font_object.name,
-                "text": self.text,
-                "antialias": False,
-                "color": "white",
-                "bgcolor": "black",  # if (self.has_alpha_color() or self.draw_mode == bf.drawMode.TEXTURED) else self.color,
-                "wraplength": (
-                    int(self.get_padded_width()) if self.auto_wraplength else 0
-                ),
-            }
-            self.text_rect.size = self._render_font(params).get_size()
+            self.text_rect.size = self._get_text_rect_required_size()
         w, h = self.text_rect.size
+        outline_offset = self._get_outline_offset()
+
         size = (
             max(
                 self.indicator.rect.w,
                 w + self.font_object.point_size + (self.gap if self.text else 0),
             ),
-            self.text_rect.h,
+            self.text_rect.h + outline_offset[1],
         )
         return self.inflate_rect_by_padding((0, 0, *size)).size
 
@@ -78,24 +71,19 @@ class Toggle(Button):
 
         gap = self.gap if self.text else 0
 
-        params = {
-            "font_name": self.font_object.name,
-            "text": self.text,
-            "antialias": False,
-            "color": "white",
-            "bgcolor": "black",  # if (self.has_alpha_color() or self.draw_mode == bf.drawMode.TEXTURED) else self.color,
-            "wraplength": int(self.get_padded_width()) if self.auto_wraplength else 0,
-        }
-        self.text_rect.size = self._render_font(params).get_size()
-
-        indicator_height = self.font_object.point_size
+        self.text_rect.size = self._get_text_rect_required_size()
 
-        self.indicator.set_size((indicator_height, indicator_height))
+        outline_offset = self._get_outline_offset()
 
         tmp_rect = pygame.FRect(
-            0, 0, self.text_rect.w + gap + indicator_height, self.text_rect.h
+            0, 0,
+            self.text_rect.w + gap + self.indicator.rect.w + outline_offset[0],
+            self.text_rect.h + outline_offset[1]
         )
 
+        point_size = min(tmp_rect.h, self.font_object.point_size)
+        self.indicator.set_size_if_autoresize((point_size,point_size))
+
         if self.autoresize_h or self.autoresize_w:
             target_rect = self.inflate_rect_by_padding(tmp_rect)
             if not self.autoresize_w:
@@ -107,20 +95,20 @@ class Toggle(Button):
                 self.build()
                 return
 
-        padded = self.get_padded_rect().move(-self.rect.x, -self.rect.y)
 
-        self.align_text(tmp_rect, padded, self.alignment)
+        padded_rect = self.get_padded_rect()
+        padded_relative = padded_rect.move(-self.rect.x, -self.rect.y)
+
+ 
+
+        self.align_text(tmp_rect, padded_relative, self.alignment)
         self.text_rect.midleft = tmp_rect.midleft
         if self.text:
             match self.spacing:
                 case bf.spacing.MAX:
-                    gap = padded.w - self.text_rect.w - self.indicator.rect.w
+                    gap = padded_relative.right - self.text_rect.right - self.indicator.rect.w
                 case bf.spacing.MIN:
                     gap = 0
 
-        self.indicator.set_position(
-            *self.text_rect.move(
-                self.rect.x + gap,
-                self.rect.y + (self.text_rect.h / 2) - self.indicator.rect.h / 2,
-            ).topright
-        )
+        self.indicator.rect.x = self.rect.x + self.text_rect.right + gap
+        self.indicator.rect.centery = self.rect.y + padded_relative.top + self.text_rect.h // 2

batFramework/gui/widget.py

@@ -188,7 +188,7 @@ class Widget(bf.Entity, metaclass=WidgetMeta):
         seen = set()
         result = []
         for c in self.constraints:
-            if c.name not in seen:
+            if not any(c == o for o in seen):
                 result.append(c)
                 seen.add(c.name)
         self.constraints = result
@@ -271,9 +271,7 @@ class Widget(bf.Entity, metaclass=WidgetMeta):
         size = list(size)
         size[0] = size[0] if self.autoresize_w else None
         size[1] = size[1] if self.autoresize_h else None
-
         self.set_size(size)
-
         return self
 
     def set_size(self, size: tuple) -> Self:
@@ -305,10 +303,12 @@ class Widget(bf.Entity, metaclass=WidgetMeta):
     def build(self) -> None:
         new_size = tuple(map(int, self.rect.size))
         if self.surface.get_size() != new_size:
+            old_alpha = self.surface.get_alpha()
             new_size = [max(0, i) for i in new_size]
             self.surface = pygame.Surface(new_size, self.surface_flags)
             if self.convert_alpha:
                 self.surface = self.surface.convert_alpha()
+            self.surface.set_alpha(old_alpha)
 
     def paint(self) -> None:
         self.surface.fill((0, 0, 0, 0))

batFramework/particle.py

@@ -36,8 +36,9 @@ class BasicParticle(TimedParticle):
         **kwargs,
     ):
         super().__init__(duration)
-        self.rect = pygame.FRect(*start_pos, *size)
-        self.surface = pygame.Surface(size).convert()
+        self.rect = pygame.FRect(0,0, *size)
+        self.rect.center = start_pos
+        self.surface = pygame.Surface(size)
         self.velocity = Vector2(start_vel)
         if color:
             self.surface.fill(color)
@@ -57,7 +58,6 @@ class BasicParticle(TimedParticle):
 
 class DirectionalParticle(BasicParticle):
     def start(self):
-        self.surface = self.surface.convert_alpha()
         self.original_surface = self.surface.copy()
 
     def update_surface(self):
@@ -96,6 +96,6 @@ class ParticleGenerator(bf.Entity):
 
     def draw(self, camera) -> bool:
         camera.surface.fblits(
-            [(p.surface, camera.world_to_screen(p.rect).center) for p in self.particles]
+            [(p.surface, camera.world_to_screen(p.rect)) for p in self.particles]
         )
         return len(self.particles)

batFramework/resourceManager.py

@@ -3,6 +3,7 @@ import os
 import pygame
 import sys
 import json
+from typing import Any
 from .utils import Singleton
 
 if getattr(sys, "frozen", False):
@@ -16,6 +17,7 @@ else:
 
 class ResourceManager(metaclass=Singleton):
     def __init__(self):
+        self.shared_variables: dict[str,Any] = {}
         self.convert_image_cache = {}
         self.convert_alpha_image_cache = {}
         self.sound_cache = {}
@@ -33,11 +35,11 @@ class ResourceManager(metaclass=Singleton):
                     # print(f"Loaded image : '{file_path}'")
 
                 elif file.lower().endswith((".mp3", ".wav")):
-                    bf.AudioManager().load_sound(file.lower().split(".")[0], file_path)
+                    bf.AudioManager().load_sound(file.split(".")[0], file_path)
                     # print(f"Loaded sound : '{file_path}'")
 
                 elif file.lower().endswith((".ttf", ".otf")):
-                    bf.FontManager().load_font(file_path, file.lower().split(".")[0])
+                    bf.FontManager().load_font(file_path, file.split(".")[0])
                     # print(f"Loaded font : '{file_path}'")
 
         print(f"Loaded resources in directory : '{path}'")
@@ -82,3 +84,17 @@ class ResourceManager(metaclass=Singleton):
             return True
         except FileNotFoundError:
             return False
+
+
+    def set_sharedVar(self, name, value) -> bool:
+        """
+        Set a shared variable of any type. This will be accessible (read/write) from any scene
+        """
+        self.shared_variables[name] = value
+        return True
+
+    def get_sharedVar(self, name, error_value=None):
+        """
+        Get a shared variable
+        """
+        return self.shared_variables.get(name, error_value)