batframework 1.0.8a14__py3-none-any.whl → 1.0.9a1__py3-none-any.whl

batFramework/__init__.py

@@ -1,6 +1,5 @@
 import pygame
 import batFramework as bf
-import sys
 from .constants import Constants as const
 from .utils import Singleton
 from .enums import *
@@ -11,7 +10,7 @@ from .tileset import Tileset
 from .timeManager import TimeManager,Timer,SceneTimer
 from .easingController import EasingController
 from .cutscene import Cutscene, CutsceneManager
-from .cutsceneBlocks import *
+import batFramework.cutsceneBlocks
 from .audioManager import AudioManager
 import batFramework.transition as transition
 from .action import Action
@@ -29,7 +28,7 @@ from .animatedSprite import AnimatedSprite
 from .character import Character
 from .stateMachine import State, StateMachine
 from .scene import Scene
-from .gui import *
+from  .gui import *
 from .sceneManager import SceneManager
 from .manager import Manager
 from .templates import *
@@ -47,8 +46,6 @@ def init_screen(resolution: tuple[int, int], flags: int = 0, vsync: int = 0):
         f"Window : {resolution[0]}x{resolution[1]}"
     )
 
-
-
 def print_version():
     package_name = "batFramework"
     try:
@@ -57,19 +54,18 @@ def print_version():
     except importlib.metadata.PackageNotFoundError:
         print(f"{package_name} is not installed")
 
-
 def init(
     resolution: tuple[int, int],
     flags: int = 0,
-    vsync: int = 0,
-    default_text_size=None,
-    default_font=None,
+    window_caption: str = "BatFramework Project",
     resource_path: str | None = None,
-    window_title: str = "BatFramework Project",
+    default_font_size=None,
+    default_font=None,
     fps_limit: int = 0,
+    vsync: int = 0,
 ):
     print_version()
-    pygame.display.set_caption(window_title)
+    pygame.display.set_caption(window_caption)
     init_screen(resolution, flags, vsync)
 
     ResourceManager().set_resource_path(
@@ -77,8 +73,8 @@ def init(
     )
     if resource_path is not None:
         ResourceManager().load_dir(ResourceManager().RESOURCE_PATH)
-    if default_text_size is not None:
-        FontManager().set_default_text_size(default_text_size)
+    if default_font_size is not None:
+        FontManager().set_default_text_size(default_font_size)
     FontManager().init_font(default_font)
     const.BF_INITIALIZED = True
     const.set_fps_limit(fps_limit)

batFramework/camera.py

@@ -213,7 +213,7 @@ class Camera:
 
         return surface
 
-    def resize(self, size: tuple[int, int] | None = None) -> Self:
+    def set_size(self, size: tuple[int, int] | None = None) -> Self:
         if size is None:
             size = bf.const.RESOLUTION
         self.target_size = size

batFramework/constants.py

@@ -16,6 +16,12 @@ class Constants:
     DEFAULT_CLICK_CURSOR = pygame.cursors.Cursor(pygame.SYSTEM_CURSOR_ARROW)
 
     BF_INITIALIZED: bool = False
+    ALLOW_DEBUG : bool = True
+
+    @staticmethod
+    def set_allow_debug(allow_debug:bool):
+        Constants.ALLOW_DEBUG = allow_debug
+
 
     @staticmethod
     def set_resolution(resolution: tuple[int, int]):

batFramework/cutscene.py

@@ -37,14 +37,13 @@ class CutsceneManager(metaclass=bf.Singleton):
             self.current_cutscene.on_enter()
             self.current_cutscene.init_blocks()
             self.current_cutscene.play()
-        self.manager.set_sharedVar("in_cutscene", True)
 
     def enable_player_control(self) -> None:
-        self.manager.set_sharedVar("player_has_control", True)
+        pass
 
     def disable_player_control(self) -> None:
-        self.manager.set_sharedVar("player_has_control", False)
-
+        pass
+    
     def update(self, dt):
         if not self.current_cutscene is None:
             self.current_cutscene.update(dt)
@@ -56,7 +55,6 @@ class CutsceneManager(metaclass=bf.Singleton):
                     self.play(self.cutscenes.pop(0))
                 else:
                     self.current_cutscene = None
-                    self.manager.set_sharedVar("in_cutscene", False)
 
 
 class Cutscene:

batFramework/drawable.py

@@ -66,7 +66,7 @@ class Drawable(Entity):
         """
         Draw the entity onto the camera surface
         """
-        if not self.visible or not camera.rect.colliderect(self.rect):
+        if not self.visible or not camera.rect.colliderect(self.rect) or self.surface.get_alpha() == 0:
             return
         camera.surface.blit(
             self.surface,

batFramework/dynamicEntity.py

@@ -6,11 +6,9 @@ from typing import Self
 class DynamicEntity(bf.Entity):
     def __init__(
         self,
-        size: None | tuple[int, int] = None,
-        surface_flags: int = 0,
-        convert_alpha: bool = False,*args,**kwargs
+        *args,**kwargs
     ) -> None:
-        super().__init__(size, surface_flags, convert_alpha,*args,**kwargs)
+        super().__init__(*args,**kwargs)
         self.velocity = pygame.math.Vector2(0, 0)
         self.ignore_collisions : bool = False
 

batFramework/entity.py

@@ -8,27 +8,27 @@ if TYPE_CHECKING:
 
 
 class Entity:
-    __count = 0
-    __available_uid = set()
-    __used_uid = set()
+    _count: int = 0
+    _available_uids: set[int] = set()
+
+
+    def __init__(self,*args,**kwargs) -> None:
+        if Entity._available_uids:
+            self.uid = Entity._available_uids.pop()
+        else:
+            self.uid = Entity._count
+            Entity._count += 1
 
-    def __init__(self) -> None:
         self.rect = pygame.FRect(0, 0, 0, 0)
         self.tags: list[str] = []
         self.parent_scene: bf.Scene | None = None
         self.debug_color: tuple | str = "red"
-        self.uid: int = Entity.__count
-        Entity.__used_uid.add(self.uid)
-
-        if Entity.__available_uid:
-            self.name = Entity.__available_uid.pop()
-        else:
-            self.name = Entity.__count
-            Entity.__count += 1
 
     def __del__(self):
-        Entity.__available_uid.add(self.uid)
-
+        try:
+            Entity._available_uids.add(self.uid)
+        except AttributeError:
+            pass
     def set_position(self, x, y) -> Self:
         self.rect.topleft = x, y
         return self
@@ -60,16 +60,6 @@ class Entity:
     def do_when_removed(self):
         pass
 
-    def set_uid(self, uid: int) -> Self:
-        if uid in Entity.__used_uid:
-            print(f"set_uid error : UID '{uid}' is already in use")
-            return self
-        self.uid = uid
-        if uid in Entity.__used_uid:
-            Entity.__used_uid.remove(uid)
-        Entity.__used_uid.add(uid)
-        return self
-
     def add_tags(self, *tags) -> Self:
         for tag in tags:
             if tag not in self.tags:
@@ -86,10 +76,7 @@ class Entity:
     def get_tags(self) -> list[str]:
         return self.tags
 
-    def process_event(self, event: pygame.Event) -> bool:
-        """
-        Returns bool : True if the method is blocking (no propagation to next Entity of the scene)
-        """
+    def process_event(self, event: pygame.Event) -> None:
         if event.consumed:
             return
         self.do_process_actions(event)

batFramework/enums.py

@@ -111,3 +111,4 @@ class textMode(Enum):
     ALPHABETICAL = 0
     NUMERICAL = 1
     ALPHANUMERICAL = 3
+    

batFramework/fontManager.py

@@ -9,17 +9,17 @@ import batFramework as bf
 class FontManager(metaclass=Singleton):
     def __init__(self):
         pygame.font.init()
-        self.DEFAULT_TEXT_SIZE = 16
+        self.DEFAULT_FONT_SIZE = 16
         self.MIN_FONT_SIZE = 8
         self.MAX_FONT_SIZE = 64
         self.DEFAULT_ANTIALIAS = False
         self.FONTS = {}
 
-    def set_antialias(self, value: bool):
+    def set_default_antialias(self, value: bool):
         self.DEFAULT_ANTIALIAS = value
 
     def set_default_text_size(self, size: int):
-        self.DEFAULT_TEXT_SIZE = size
+        self.DEFAULT_FONT_SIZE = size
 
     def init_font(self, raw_path: str | None):
         try:

batFramework/gui/__init__.py

@@ -1,4 +1,3 @@
-from .constraints import *
 from .widget import Widget
 from .styleManager import StyleManager
 from .style import Style
@@ -10,7 +9,7 @@ from .root import Root
 from .shape import Shape
 from .meter import Meter
 from .label import Label
-from .dialogueBox import DialogueBox
+from .animatedLabel import AnimatedLabel
 from .textInput import TextInput
 from .button import Button
 from .debugger import *
@@ -20,3 +19,4 @@ from .indicator import *
 from .toggle import Toggle
 from .radioButton import RadioButton, RadioVariable
 from .slider import Slider
+from .constraints import *

batFramework/gui/{dialogueBox.py → animatedLabel.py}

@@ -3,19 +3,20 @@ import batFramework as bf
 from typing import Self
 
 
-class DialogueBox(Label):
-    def __init__(self) -> None:
+class AnimatedLabel(Label):
+    def __init__(self,text="") -> 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.original_text = ""
         self.set_autoresize(False)
         self.set_alignment(bf.alignment.LEFT)
         super().__init__("")
+        self.set_text(text)
 
     def __str__(self) -> str:
-        return "DialogueBox"
+        return "AnimatedLabel"
 
     def pause(self) -> Self:
         self.is_paused = True
@@ -53,47 +54,28 @@ class DialogueBox(Label):
                 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
+    def _set_text_internal(self,text:str)->Self:
+        super().set_text(text)
         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)
+    def set_text(self,text:str)->Self:
+        self.original_text = text
+        self.is_over = False
         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 set_size(self, size):
+        super().set_size(size)
+        self._set_text_internal('\n'.join(self.cut_text_to_width(self.original_text[: int(self.cursor_position)])))
 
     def do_update(self, dt):
-        if not self.message_queue or self.is_paused:
+        if self.is_over:
             return
-        if not self.is_over and self.cursor_position == len(self.message_queue[0]):
+        if not self.is_over and self.cursor_position == len(self.original_text):
             self.is_over = True
             return
         self.cursor_position = min(
-            self.cursor_position + self.text_speed * dt, len(self.message_queue[0])
+            self.cursor_position + self.text_speed * dt, len(self.original_text)
         )
-        self.set_text(self.message_queue[0][: int(self.cursor_position)])
+        # self.set_text(self.original_text[: int(self.cursor_position)])
+        self._set_text_internal('\n'.join(self.cut_text_to_width(self.original_text[: int(self.cursor_position)])))

batFramework/gui/button.py

@@ -13,3 +13,33 @@ class Button(Label, ClickableWidget):
 
     def __str__(self) -> str:
         return f"Button({self.text})"
+
+    def get_min_required_size(self) -> tuple[float, float]:
+        if not (self.autoresize_w or self.autoresize_h):
+            return self.rect.size
+        if not self.text_rect:
+            self.text_rect.size = self._get_text_rect_required_size()
+        res = self.inflate_rect_by_padding((0, 0, *self.text_rect.size)).size
+        res = res[0],res[1]+self.unpressed_relief
+        return res[0] if self.autoresize_w else self.rect.w, (
+            res[1] if self.autoresize_h else self.rect.h
+        )
+
+
+    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))
+            target_rect.h += self.unpressed_relief
+            if not self.autoresize_w:
+                target_rect.w = self.rect.w
+            if not self.autoresize_h:
+                target_rect.h = self.rect.h
+            if self.rect.size != target_rect.size:
+                self.set_size(target_rect.size)
+                self.apply_updates()
+                return
+        offset = self._get_outline_offset() if self.show_text_outline else (0,0)
+        padded = self.get_padded_rect().move(-self.rect.x + offset[0], -self.rect.y + offset[1])
+        self.align_text(self.text_rect, padded, self.alignment)

batFramework/gui/clickableWidget.py

@@ -27,6 +27,11 @@ class ClickableWidget(Shape, InteractiveWidget):
         self.set_debug_color("cyan")
         self.set_relief(self.unpressed_relief)
 
+    def get_min_required_size(self) -> tuple[float, float]:
+        return self.rect.size.inflate(0,self.unpressed_relief)
+
+
+
     def set_unpressed_relief(self, relief: int) -> Self:
         if relief == self.unpressed_relief:
             return self
@@ -217,4 +222,4 @@ class ClickableWidget(Shape, InteractiveWidget):
             self._paint_disabled()
         elif self.is_hovered:
             self._paint_hovered()
- 
+ 

batFramework/gui/constraints/constraints.py

@@ -598,6 +598,95 @@ class MarginRight(Constraint):
             other.margin == self.margin
         )
 
+class RectMarginBottom(Constraint):
+    def __init__(self, margin: float):
+        super().__init__()
+        self.margin = margin
+
+    def evaluate(self, parent_widget, child_widget):
+        return (
+            child_widget.rect.bottom == parent_widget.rect.bottom - self.margin
+        )
+
+    def apply_constraint(self, parent_widget, child_widget):
+        child_widget.set_position(
+            child_widget.rect.x,
+            parent_widget.rect.bottom- child_widget.rect.h - self.margin,
+        )
+
+    def __eq__(self,other:"Constraint")->bool:
+        if not isinstance(other,self.__class__):
+            return False
+        return (
+            other.name == self.name and
+            other.margin == self.margin
+        )
+
+class RectMarginTop(Constraint):
+    def __init__(self, margin: float):
+        super().__init__()
+        self.margin = margin
+
+    def evaluate(self, parent_widget, child_widget):
+        return child_widget.rect.top == parent_widget.rect.top + self.margin
+
+    def apply_constraint(self, parent_widget, child_widget):
+        child_widget.set_position(
+            child_widget.rect.x, parent_widget.rect.top + self.margin
+        )
+
+    def __eq__(self,other:"Constraint")->bool:
+        if not isinstance(other,self.__class__):
+            return False
+        return (
+            other.name == self.name and
+            other.margin == self.margin
+        )
+
+class RectMarginLeft(Constraint):
+    def __init__(self, margin: float):
+        super().__init__()
+        self.margin = margin
+
+    def evaluate(self, parent_widget, child_widget):
+        return child_widget.rect.left == parent_widget.rect.left + self.margin
+
+    def apply_constraint(self, parent_widget, child_widget):
+        if not self.evaluate(parent_widget, child_widget):
+            child_widget.set_position(
+                parent_widget.rect.left + self.margin, child_widget.rect.y
+            )
+
+    def __eq__(self,other:"Constraint")->bool:
+        if not isinstance(other,self.__class__):
+            return False
+        return (
+            other.name == self.name and
+            other.margin == self.margin
+        )
+
+class RectMarginRight(Constraint):
+    def __init__(self, margin: float):
+        super().__init__()
+        self.margin = margin
+
+    def evaluate(self, parent_widget, child_widget):
+        return child_widget.rect.right == parent_widget.rect.right - self.margin
+
+    def apply_constraint(self, parent_widget, child_widget):
+        child_widget.set_position(
+            parent_widget.rect.right - child_widget.rect.w - self.margin,
+            child_widget.rect.y,
+        )
+
+    def __eq__(self,other:"Constraint")->bool:
+        if not isinstance(other,self.__class__):
+            return False
+        return (
+            other.name == self.name and
+            other.margin == self.margin
+        )
+
 class PercentageMarginBottom(Constraint):
     def __init__(self, margin: float):
         super().__init__()
@@ -812,4 +901,4 @@ class PercentageRectMarginRight(Constraint):
         return (
             other.name == self.name and
             other.margin == self.margin
-        )
+        )