batframework 1.0.8a13__tar.gz → 1.0.9a1__tar.gz

{batframework-1.0.8a13/src/batframework.egg-info → batframework-1.0.9a1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: batframework
-Version: 1.0.8a13
+Version: 1.0.9a1
 Summary: Pygame framework for making games easier.
 Author-email: Turan Baturay <baturayturan@gmail.com>
 Project-URL: Homepage, https://github.com/TuranBaturay/batFramework

{batframework-1.0.8a13 → batframework-1.0.9a1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "batframework"
-version = "1.0.8a13"
+version = "1.0.9a1"
 description = "Pygame framework for making games easier."
 readme = "README.md"
 classifiers = [ "Programming Language :: Python :: 3", "License :: OSI Approved :: MIT License", "Operating System :: OS Independent",]

{batframework-1.0.8a13 → batframework-1.0.9a1}/src/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-1.0.8a13 → batframework-1.0.9a1}/src/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-1.0.8a13 → batframework-1.0.9a1}/src/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-1.0.8a13 → batframework-1.0.9a1}/src/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-1.0.8a13 → batframework-1.0.9a1}/src/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-1.0.8a13 → batframework-1.0.9a1}/src/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-1.0.8a13/src/batFramework/entity.py → batframework-1.0.9a1/src/batFramework/drawable.py

@@ -1,10 +1,10 @@
 from typing import Any, Self
 import pygame
 import batFramework as bf
-from .object import Object
+from .entity import Entity
 
 
-class Entity(Object):
+class Drawable(Entity):
     """
     Basic entity class
     """
@@ -19,6 +19,7 @@ class Entity(Object):
     ) -> 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
@@ -65,7 +66,7 @@ class Entity(Object):
         """
         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-1.0.8a13 → batframework-1.0.9a1}/src/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-1.0.8a13/src/batFramework/object.py → batframework-1.0.9a1/src/batFramework/entity.py

@@ -7,29 +7,28 @@ if TYPE_CHECKING:
     from .camera import Camera
 
 
-class Object:
-    __count = 0
-    __available_uid = set()
-    __used_uid = set()
+class Entity:
+    _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.render_order: int = 0
-        self.uid: int = Object.__count
-        Object.__used_uid.add(self.uid)
-
-        if Object.__available_uid:
-            self.name = Object.__available_uid.pop()
-        else:
-            self.name = Object.__count
-            Object.__count += 1
 
     def __del__(self):
-        Object.__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
@@ -61,14 +60,6 @@ class Object:
     def do_when_removed(self):
         pass
 
-    def set_uid(self, uid: int) -> Self:
-        if uid in Object.__used_uid:
-            print(f"set_uid error : UID '{uid}' is already in use")
-            return self
-        self.uid = uid
-        Object.__used_uid.add(uid)
-        return self
-
     def add_tags(self, *tags) -> Self:
         for tag in tags:
             if tag not in self.tags:
@@ -85,10 +76,7 @@ class Object:
     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 object of the scene)
-        """
+    def process_event(self, event: pygame.Event) -> None:
         if event.consumed:
             return
         self.do_process_actions(event)
@@ -112,7 +100,7 @@ class Object:
 
     def update(self, dt: float) -> None:
         """
-        Update method to be overriden by subclasses of object (must call do_update and do_reset_actions)
+        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()

{batframework-1.0.8a13 → batframework-1.0.9a1}/src/batFramework/enums.py

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

{batframework-1.0.8a13 → batframework-1.0.9a1}/src/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-1.0.8a13 → batframework-1.0.9a1}/src/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-1.0.8a13/src/batFramework/gui/dialogueBox.py → batframework-1.0.9a1/src/batFramework/gui/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-1.0.9a1/src/batFramework/gui/button.py

@@ -0,0 +1,45 @@
+from .label import Label
+import batFramework as bf
+from typing import Self, Callable
+from .clickableWidget import ClickableWidget
+import pygame
+from math import ceil
+
+
+class Button(Label, ClickableWidget):
+    def __init__(self, text: str = "", callback: None | Callable = None) -> None:
+        super().__init__(text=text)
+        self.set_callback(callback)
+
+    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-1.0.8a13 → batframework-1.0.9a1}/src/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-1.0.8a13 → batframework-1.0.9a1}/src/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
-        )
+        )