batframework 1.0.8a13__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 *
@@ -8,17 +7,17 @@ from .resourceManager import ResourceManager
 from .fontManager import FontManager
 from .utils import Utils as utils
 from .tileset import Tileset
-from .time import *
+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
 from .actionContainer import *
 from .camera import Camera
-from .object import Object
 from .entity import Entity
+from .drawable import Drawable
 from .renderGroup import RenderGroup
 from .dynamicEntity import DynamicEntity
 from .sprite import Sprite
@@ -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/animatedSprite.py

@@ -3,7 +3,7 @@ import pygame
 from typing import List, Dict, Tuple, Union, Optional, Self
 from .animation import Animation
 
-class AnimatedSprite(bf.Entity):
+class AnimatedSprite(bf.Drawable):
     def __init__(self, size: Optional[Tuple[int, int]] = None,*args,**kwargs) -> None:
         super().__init__(size, no_surface=True,*args,**kwargs)
         self.float_counter: float = 0

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/character.py

@@ -3,7 +3,7 @@ from .stateMachine import State
 from .animatedSprite import AnimatedSprite
 from .dynamicEntity import DynamicEntity
 
-class Character(AnimatedSprite,DynamicEntity):
+class Character(DynamicEntity,AnimatedSprite):
     def __init__(self,*args,**kwargs) -> None:
         super().__init__(*args,**kwargs)
         self.state_machine = bf.StateMachine(self)

batFramework/constants.py

@@ -4,6 +4,8 @@ import pygame
 class Constants:
     SCREEN: pygame.Surface = None
     RESOLUTION: tuple[int, int] = (1280, 720)
+    WIDTH = 1280
+    HEIGHT = 720
     VSYNC = 0
     FLAGS: int = pygame.SCALED | pygame.RESIZABLE
     FPS: int = 60
@@ -14,10 +16,18 @@ 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]):
         Constants.RESOLUTION = resolution
+        Constants.WIDTH = resolution[0]
+        Constants.HEIGHT = resolution[1]
 
     @staticmethod
     def set_default_cursor(cursor: pygame.Cursor):

batFramework/cutscene.py

@@ -1,5 +1,5 @@
 import batFramework as bf
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING,Self
 
 class CutsceneBlock: ...
 
@@ -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:
@@ -75,13 +73,15 @@ class Cutscene:
     def init_blocks(self):
         pass
 
-    def add_blocks(self, *blocks: CutsceneBlock):
+    def add_blocks(self, *blocks: CutsceneBlock)->Self:
         self.cutscene_blocks.extend(blocks)
-
-    def add_end_blocks(self, *blocks: CutsceneBlock):
+        return self
+        
+    def add_end_blocks(self, *blocks: CutsceneBlock)->Self:
         _ = [block.set_parent_cutscene(self) for block in blocks]
         self.end_blocks.extend(blocks)
-
+        return self
+        
     def get_scene_at(self, index):
         return bf.CutsceneManager().manager.scenes[index]
 

batFramework/drawable.py

@@ -0,0 +1,75 @@
+from typing import Any, Self
+import pygame
+import batFramework as bf
+from .entity import Entity
+
+
+class Drawable(Entity):
+    """
+    Basic entity class
+    """
+
+    def __init__(
+        self,
+        size: None | tuple[int, int] = None,
+        surface_flags: int = 0,
+        convert_alpha: bool = False,
+        *args,
+        **kwargs,
+    ) -> None:
+        super().__init__()
+        self.visible: bool = True
+        self.render_order: int = 0
+        self.rect.size = (10, 10) if size is None else size
+        self.convert_alpha: bool = convert_alpha
+        self.surface_flags: int = surface_flags
+        self.blit_flags: int = 0
+        self.surface: pygame.Surface = pygame.Surface(self.rect.size, surface_flags)
+        if convert_alpha:
+            self.surface = self.surface.convert_alpha()
+            self.surface.fill((0, 0, 0, 0))
+
+    def set_alpha(self, alpha: int) -> Self:
+        self.surface.set_alpha(min(max(0, alpha), 255))
+        return self
+
+    def get_alpha(self) -> int:
+        return self.surface.get_alpha()
+
+    def set_surface_flags(self, surface_flags: int) -> Self:
+        self.surface_flags = surface_flags
+        return self
+
+    def set_convert_alpha(self, value: bool) -> Self:
+        self.convert_alpha = value
+        return self
+
+    def set_blit_flags(self, blit_flags: int) -> Self:
+        self.blit_flags = blit_flags
+        return self
+
+    def get_debug_outlines(self):
+        if self.visible:
+            yield (self.rect, self.debug_color)
+
+    def set_render_order(self, render_order: int) -> Self:
+        self.render_order = render_order
+        if self.parent_scene:
+            self.parent_scene.sort_entities()
+        return self
+
+    def set_visible(self, value: bool) -> Self:
+        self.visible = value
+        return self
+
+    def draw(self, camera: bf.Camera) -> None:
+        """
+        Draw the entity onto the camera surface
+        """
+        if not self.visible or not camera.rect.colliderect(self.rect) or self.surface.get_alpha() == 0:
+            return
+        camera.surface.blit(
+            self.surface,
+            camera.world_to_screen(self.rect),
+            special_flags=self.blit_flags,
+        )

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

@@ -1,74 +1,111 @@
 from typing import Any, Self
 import pygame
 import batFramework as bf
-from .object import Object
-
-
-class Entity(Object):
-    """
-    Basic entity class
-    """
-
-    def __init__(
-        self,
-        size: None | tuple[int, int] = None,
-        surface_flags: int = 0,
-        convert_alpha: bool = False,
-        *args,
-        **kwargs,
-    ) -> None:
-        super().__init__()
-        self.visible: bool = True
-        self.rect.size = (10, 10) if size is None else size
-        self.convert_alpha: bool = convert_alpha
-        self.surface_flags: int = surface_flags
-        self.blit_flags: int = 0
-        self.surface: pygame.Surface = pygame.Surface(self.rect.size, surface_flags)
-        if convert_alpha:
-            self.surface = self.surface.convert_alpha()
-            self.surface.fill((0, 0, 0, 0))
-
-    def set_alpha(self, alpha: int) -> Self:
-        self.surface.set_alpha(min(max(0, alpha), 255))
-        return self
+from typing import TYPE_CHECKING
 
-    def get_alpha(self) -> int:
-        return self.surface.get_alpha()
+if TYPE_CHECKING:
+    from .camera import Camera
+
+
+class Entity:
+    _count: int = 0
+    _available_uids: set[int] = set()
 
-    def set_surface_flags(self, surface_flags: int) -> Self:
-        self.surface_flags = surface_flags
-        return self
 
-    def set_convert_alpha(self, value: bool) -> Self:
-        self.convert_alpha = value
+    def __init__(self,*args,**kwargs) -> None:
+        if Entity._available_uids:
+            self.uid = Entity._available_uids.pop()
+        else:
+            self.uid = Entity._count
+            Entity._count += 1
+
+        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"
+
+    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
 
-    def set_blit_flags(self, blit_flags: int) -> Self:
-        self.blit_flags = blit_flags
+    def set_center(self, x, y) -> Self:
+        self.rect.center = x, y
         return self
 
     def get_debug_outlines(self):
-        if self.visible:
-            yield (self.rect, self.debug_color)
+        yield (self.rect, self.debug_color)
+
+    def set_debug_color(self, color) -> Self:
+        self.debug_color = color
+        return self
 
-    def set_render_order(self, render_order: int) -> Self:
-        self.render_order = render_order
-        if self.parent_scene:
-            self.parent_scene.sort_entities()
+    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()
+        self.parent_scene = scene
+        if scene is not None:
+            self.do_when_added()
         return self
 
-    def set_visible(self, value: bool) -> Self:
-        self.visible = value
+    def do_when_added(self):
+        pass
+
+    def do_when_removed(self):
+        pass
+
+    def add_tags(self, *tags) -> Self:
+        for tag in tags:
+            if tag not in self.tags:
+                self.tags.append(tag)
+        self.tags.sort()
         return self
 
-    def draw(self, camera: bf.Camera) -> None:
+    def remove_tags(self, *tags):
+        self.tags = [tag for tag in self.tags if tag not in tags]
+
+    def has_tags(self, *tags) -> bool:
+        return all(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:
         """
-        Draw the entity onto the camera surface
+        Process entity actions you may have set
+        """
+
+    def do_reset_actions(self) -> None:
+        """
+        Reset entity actions you may have set
+        """
+
+    def do_handle_event(self, event: pygame.Event):
+        """
+        Handle specific events with no action support
+        """
+        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)
+        """
+        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
         """
-        if not self.visible or not camera.rect.colliderect(self.rect):
-            return
-        camera.surface.blit(
-            self.surface,
-            camera.world_to_screen(self.rect),
-            special_flags=self.blit_flags,
-        )

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()
- 
+