batframework 1.0.8a7__py3-none-any.whl → 1.0.8a8__py3-none-any.whl

batframework-1.0.8a8.dist-info/METADATA

@@ -0,0 +1,53 @@
+Metadata-Version: 2.1
+Name: batframework
+Version: 1.0.8a8
+Summary: Pygame framework for making games easier.
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: pygame-ce
+
+# batFramework
+
+batFramework is a Python game framework built using Pygame, designed to simplify game development by providing entities, scenes, a scene manager, and various utilities.
+
+## Purpose and Overview
+The primary objective of batFramework is to streamline game development by utilizing entities and scenes that hold entities. It employs a manager, which inherits from the scene manager, to handle scenes, propagate events, and manage updates and rendering.
+
+## Installation and Setup
+To install batFramework, you can use pip:
+```pip install batFramework```
+
+
+The only dependency required is pygame-ce.
+
+## Usage Instructions
+To create a basic app using batFramework, here's an example:
+
+```python
+import batFramework as bf
+
+# Initialize the framework
+bf.init((1280, 720), window_title="My Amazing Program")
+
+# Create a manager and a scene
+bf.Manager(bf.Scene("main")).run()
+```
+In practice, users can inherit bf.Scene to create their own scenes, adding specific behaviors, entities, etc.
+
+## Features and Functionalities
+
+- Scene management for organizing game components
+- Cutscene support to facilitate storytelling sequences
+- Audio management for music and sound effects with volume control
+- Entity, sprite, and animated sprite support
+- Utility modules such as time management and easingAnimation
+
+Users can leverage these functionalities to build games efficiently using batFramework.
+
+For more detailed usage and examples, please refer to the documentation or codebase.
+
+
+# License
+ MIT License
+
+

batframework-1.0.8a8.dist-info/RECORD

@@ -0,0 +1,42 @@
+batFramework/__init__.py,sha256=MLVXC2ymkO3k8LdCgB6TbahgJfhxk4GKAbmndmEgZS4,2146
+batFramework/action.py,sha256=Phk6-q2P-XyV2GVlXPpxyje0due4fIrKnhI1_4anfjI,7600
+batFramework/actionContainer.py,sha256=K9dIgG559ckxzRB3t-lpON4dFTcM2mcKZfsf4bhuJ1k,1092
+batFramework/animatedSprite.py,sha256=kJPKrTOfkbQu2uYDziIEop1z6-gjBwZxkC1Rxd_vBwE,3992
+batFramework/audioManager.py,sha256=5UsDPy4zsDO7Va1y1kM4lSpEJXU95o9F01E-Sts3osg,2546
+batFramework/camera.py,sha256=wt4TyWTgQmQElBVeFI7ONzNI75r0FKtB3KmNH00GeFM,4322
+batFramework/constants.py,sha256=FSyEYLxdAb3JaXA11sAwZBfAImedASohpFcd_7qnG0I,2075
+batFramework/cutscene.py,sha256=5aiIQeWGmvHCb-N3vjmwxhE4dCXv3iZRFHiexSNxCXM,3650
+batFramework/cutsceneBlocks.py,sha256=1gmof0jKJ8SqE-RoErm6n1A0JJ4Ang9Q30xEZnW9NaI,5123
+batFramework/debugger.py,sha256=gh5kOUmGr4t-BFXA17tImid4nzxUqrhsUhE_JV9srNg,1671
+batFramework/dynamicEntity.py,sha256=REIqH0jnfX6yUThoQNkQrsG0390TR6C5la1h2MAioYk,665
+batFramework/easing.py,sha256=vGkk7FDPj27X7NCJXALCEyVKDbpXXebWYtMvxkbhOh0,2217
+batFramework/entity.py,sha256=Tw4_PIA_sY8fhbj9TjE6wPcDTrZZX_Tj7l8oKquqe8U,3178
+batFramework/manager.py,sha256=LdiQVyuPQE23jwO4EjR4zqDymxtRmthUJ7VE7RIEDpU,1583
+batFramework/particles.py,sha256=PX8zSqOS1gyDloGAz3fAlrto51lWMUpBXDIM152EYWc,2172
+batFramework/scene.py,sha256=KM1e53ZfPvuJoSGQZaEl_IouWRYCbFq0QOYTuXYCr-E,7324
+batFramework/sceneManager.py,sha256=sFkQbfMuR19M4duvCf0SOxSY7MkMrkmiiKh72-tC1nI,5743
+batFramework/stateMachine.py,sha256=_er9_dcm6MLmlTjXTVm175eqZ9puaKb31PFmNPRhcSU,1338
+batFramework/time.py,sha256=iGV9mxUFrdXsvm4fJ1faX-VYNsOH7DX2N_aXsDRHhmM,2403
+batFramework/transition.py,sha256=wmL1Mgg_xopzeDbEPJyAmllLB2BCRJZtuMOR7Mez480,4873
+batFramework/transitionManager.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+batFramework/triggerZone.py,sha256=ikOOlJT1KIND0MO2xiilCHuKlb1eQhkCMEhZTi1btsI,586
+batFramework/utils.py,sha256=EUB3bMldWTYFVZxcJk5_7XAWcEz080P7PT5ZtkO5TAQ,6164
+batFramework/gui/__init__.py,sha256=azu5HpC8Q9kupythU5GN5blt7K9oH55oXlOeXsIw1Mw,391
+batFramework/gui/button.py,sha256=05RMQ20P5npgU9QmiT8v6abJhnhjqRgYbpZGaQXr6Bg,2703
+batFramework/gui/constraints.py,sha256=pUTNwJqI2Tu57l8ZeQXVXg3b5F5t3aR4Us-CD5qXwnM,7544
+batFramework/gui/container.py,sha256=XAkPZ0BOVXxzxWP5mKDF_MjYPPPAmUBY-J5zIadO0wQ,1480
+batFramework/gui/debugger.py,sha256=JORHcSYQQCZ0tDzjnNQvDSOOjZVwEQLeqlr8e6xk2RI,1379
+batFramework/gui/frame.py,sha256=zjHwbQT1fpRuvNgfBGZhMO_GdMEWqExa5dNlN9kUnUM,514
+batFramework/gui/image.py,sha256=goOcPntsJeTb3LR7avzi4cXfYHwyGb0KXYttbCiE6fA,777
+batFramework/gui/indicator.py,sha256=OgqDFsi2HCfbSzVjHkHO_shmo4q4ro3wfd0LWSLTJeQ,957
+batFramework/gui/interactiveWidget.py,sha256=rRElxI1eFkvOeTfTaA6f8kVTOswOD-DFLAJDUCAI_Yk,641
+batFramework/gui/label.py,sha256=EO1J5zPVe1skHz-KVqXKBZVKug8UVJUCXyHnvdRDuig,3586
+batFramework/gui/layout.py,sha256=HyVhYTy1AQacALg6XMY5aX5lj7WY__HCCh8sTSBXwgI,3210
+batFramework/gui/root.py,sha256=mhlu8ohqq8N-8q__ugv_tGRgPv-1jIHXBFezMFZ4mUM,1763
+batFramework/gui/shape.py,sha256=CYaD0BdCiuGJO_tS2pALfKPlNGaGRNPzvy-Lk08_R8g,2490
+batFramework/gui/toggle.py,sha256=jAeEyQXA893gDBUmjN7aoGgfsVln5RTODpSFB4LxwTY,2020
+batFramework/gui/widget.py,sha256=1PkxThmet8nI5rvSDE6-iPtD_DsZkk-OxriZHbBZaFc,10509
+batframework-1.0.8a8.dist-info/METADATA,sha256=5bEry2ZJ0j3qgR_eOW9-JmYTInWo72i2dQxnnYPV07s,1713
+batframework-1.0.8a8.dist-info/WHEEL,sha256=5Mi1sN9lKoFv_gxcPtisEVrJZihrm_beibeg5R6xb4I,91
+batframework-1.0.8a8.dist-info/top_level.txt,sha256=vxAKBIk1oparFTxeXGBrgfIO7iq_YR5Fv1JvPVAIwmA,13
+batframework-1.0.8a8.dist-info/RECORD,,

{batframework-1.0.8a7.dist-info → batframework-1.0.8a8.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (74.1.2)
+Generator: setuptools (75.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

batFramework/character.py

@@ -1,27 +0,0 @@
-import batFramework as bf
-from .stateMachine import State
-from .animatedSprite import AnimatedSprite
-from .dynamicEntity import DynamicEntity
-
-class Character(AnimatedSprite,DynamicEntity):
-    def __init__(self) -> None:
-        super().__init__()
-        self.state_machine = bf.StateMachine(self)
-        self.do_setup_animations()
-        self.do_setup_states()
-
-    def set_state(self,state_name:str):
-        self.state_machine.set_state(state_name)
-
-    def get_current_state(self)->State:
-        return self.state_machine.get_current_state()
-    
-    def update(self, dt: float) -> None:
-        self.state_machine.update(dt)
-        super().update(dt)
-
-    def do_setup_states(self):
-        pass
-    
-    def do_setup_animations(self):
-        pass

batFramework/easingController.py

@@ -1,58 +0,0 @@
-import pygame
-import batFramework as bf
-from functools import lru_cache
-from .enums import easing
-
-
-@lru_cache(maxsize=None)
-def process_value(progress: float, p0: float, p1: float, p2: float, p3: float) -> float:
-    if p0 == 0 and p1 == 0 and p2 == 1 and p3 == 1:  # Linear easing control points
-        return progress
-    t = progress
-    t_inv = 1.0 - t
-    t2 = t * t
-    t3 = t * t2
-    t_inv2 = t_inv * t_inv
-    return 3 * t_inv2 * t * p1 + 3 * t_inv * t2 * p3 + t3
-
-
-class EasingController(bf.Timer):
-    def __init__(
-        self,
-        easing_function: easing = easing.LINEAR,
-        duration: float = 1,
-        update_callback=None,
-        end_callback=None,
-        loop: bool = False,
-    ) -> None:
-        self.easing_function = easing_function
-        self.update_callback = update_callback
-        self.value: float = 0.0
-        super().__init__(duration, end_callback, loop)
-
-    def get_value(self) -> float:
-        return self.value
-
-    def start(self, force: bool = False):
-        super().start(force)
-        self.value = 0
-
-    def update(self, dt: float) -> None:
-        if self.get_progression() == 1:
-            return
-        super().update(dt)
-        if self.get_progression() == 0:
-            return
-        if self.easing_function == easing.LINEAR:
-            self.value = self.get_progression()
-        else:
-            self.value = process_value(
-                self.get_progression(), *self.easing_function.control_points
-            )
-        if self.update_callback:
-            self.update_callback(self.value)
-
-    def end(self):
-        if self.update_callback:
-            self.update_callback(1)
-        super().end()

batFramework/enums.py

@@ -1,113 +0,0 @@
-from enum import Enum
-
-
-class color:
-    WHITE = (255, 255, 255)
-    LIGHTER_GRAY = (236, 240, 241)
-    LIGHT_GRAY = (189, 195, 199)
-    DARK_GRAY = (66, 66, 66)
-    DARKER_GRAY = (23, 23, 23)
-    BLACK = (0, 0, 0)
-
-    TURQUOISE = (26, 188, 156)
-    TURQUOISE_SHADE = (22, 160, 133)
-
-    GREEN = (46, 204, 113)
-    GREEN_SHADE = (39, 174, 96)
-
-    BLUE = (52, 152, 219)
-    BLUE_SHADE = (41, 128, 185)
-
-    PURPLE = (155, 89, 182)
-    PURPLE_SHADE = (142, 68, 173)
-
-    CHARCOAL = (52, 73, 94)
-    CHARCOAL_SHADE = (44, 62, 80)
-
-    GOLD = (241, 196, 15)
-    GOLD_SHADE = (243, 156, 18)
-
-    ORANGE = (230, 126, 34)
-    ORANGE_SHADE = (211, 84, 0)
-
-    RED = (231, 76, 60)
-    RED_SHADE = (192, 57, 43)
-
-    CLOUD = (236, 240, 241)
-    CLOUD_SHADE = (189, 195, 199)
-
-    CONCRETE = (149, 165, 166)
-    CONCRETE_SHADE = (127, 140, 141)
-
-    # GB
-    DARKER_GB = (27, 42, 9)
-    DARK_GB = (14, 69, 11)
-    LIGHT_GB = (73, 107, 34)
-    LIGHTER_GB = (154, 158, 63)
-
-
-class easing(Enum):
-    LINEAR = (0, 0, 1, 1)
-    EASE_IN = (0.95, 0, 1, 0.55)
-    EASE_OUT = (0.5, 1, 0.5, 1)
-    EASE_IN_OUT = (0.55, 0, 0.45, 1)
-    EASE_IN_OUT_ELASTIC = (0.76,-0.36,0.41,1.34)
-
-    def __init__(self, *control_points):
-        self.control_points = control_points
-
-
-class axis(Enum):
-    HORIZONTAL = "horizontal"
-    VERTICAL = "vertical"
-
-
-class spacing(Enum):
-    MIN = "min"
-    HALF = "half"
-    MAX = "max"
-    MANUAL = "manual"
-
-
-class alignment(Enum):
-    LEFT = "left"
-    RIGHT = "right"
-    CENTER = "center"
-    TOP = "top"
-    BOTTOM = "bottom"
-    TOPLEFT = "topleft"
-    TOPRIGHT = "topright"
-    MIDLEFT = "midleft"
-    MIDRIGHT = "midright"
-    BOTTOMLEFT = "bottomleft"
-    BOTTOMRIGHT = "bottomright"
-
-
-class direction(Enum):
-    LEFT = 0
-    UP = 1
-    RIGHT = 2
-    DOWN = 3
-
-
-class drawMode(Enum):
-    SOLID = 0
-    TEXTURED = 1
-
-
-class debugMode(Enum):
-    HIDDEN = 0
-    DEBUGGER = 1
-    OUTLINES = 2
-
-
-class actionType(Enum):
-    INSTANTANEOUS = 0
-    CONTINUOUS = 1
-    HOLDING = 2
-
-
-class textMode(Enum):
-    ALPHABETICAL = 0
-    NUMERICAL = 1
-    ALPHANUMERICAL = 3

batFramework/fontManager.py

@@ -1,65 +0,0 @@
-from .utils import Singleton
-
-# put font stuff here later
-import pygame
-import os
-import batFramework as bf
-
-
-class FontManager(metaclass=Singleton):
-    def __init__(self):
-        pygame.font.init()
-        self.DEFAULT_TEXT_SIZE = 16
-        self.MIN_FONT_SIZE = 8
-        self.MAX_FONT_SIZE = 64
-        self.DEFAULT_ANTIALIAS = False
-        self.FONTS = {}
-
-    def set_antialias(self, value: bool):
-        self.DEFAULT_ANTIALIAS = value
-
-    def set_default_text_size(self, size: int):
-        self.DEFAULT_TEXT_SIZE = size
-
-    def init_font(self, raw_path: str | None):
-        try:
-            if raw_path is not None:
-                self.load_font(raw_path if raw_path else None, None)
-            self.load_font(raw_path)
-        except FileNotFoundError:
-            self.load_sysfont(raw_path)
-            self.load_sysfont(raw_path, None)
-
-    def load_font(self, path: str | None, name: str | None = ""):
-        if path is not None:
-            path = bf.ResourceManager().get_path(path)  # convert path if given
-        filename = None
-        if path is not None:
-            filename = os.path.basename(path).split(".")[0]
-
-        # get filename if path is given, else None
-        if name != "":
-            filename = name  # if name is not given, name is the filename
-        self.FONTS[filename] = {}
-        # fill the dict
-        for size in range(self.MIN_FONT_SIZE, self.MAX_FONT_SIZE+1, 2):
-            self.FONTS[filename][size] = pygame.font.Font(path, size=size)
-
-    def load_sysfont(self, font_name: str | None, key: str | None = ""):
-        if key == "":
-            key = font_name
-        if font_name is None or pygame.font.match_font(font_name) is None:
-            raise FileNotFoundError(f"Requested font '{font_name}' was not found")
-        self.FONTS[font_name] = {}
-
-        for size in range(self.MIN_FONT_SIZE, self.MAX_FONT_SIZE+1, 2):
-            self.FONTS[key][size] = pygame.font.SysFont(font_name, size=size)
-
-    def get_font(
-        self, name: str | None = None, text_size: int = 12
-    ) -> pygame.Font | None:
-        if not name in self.FONTS:
-            return None
-        if not text_size in self.FONTS[name]:
-            return None
-        return self.FONTS[name][text_size]

batFramework/gui/clickableWidget.py

@@ -1,220 +0,0 @@
-from .label import Label
-import batFramework as bf
-from typing import Self, Callable
-from .interactiveWidget import InteractiveWidget
-from .shape import Shape
-import pygame
-from math import ceil
-
-
-class ClickableWidget(Shape, InteractiveWidget):
-    _cache: dict = {}
-
-    def __init__(self, callback: None | Callable = None, *args, **kwargs) -> None:
-        super().__init__(*args, **kwargs)
-        self.callback = callback
-        self.is_pressed: bool = False
-        self.enabled: bool = True
-        self.hover_cursor = bf.const.DEFAULT_HOVER_CURSOR
-        self.click_cursor = bf.const.DEFAULT_CLICK_CURSOR
-        self.click_down_sound = None
-        self.click_up_sound = None
-        self.get_focus_sound = None
-        self.lose_focus_sound = None
-        self.pressed_relief: int = 1
-        self.unpressed_relief: int = 2
-        self.silent_focus: bool = False
-        self.set_debug_color("cyan")
-        self.set_relief(self.unpressed_relief)
-
-    def set_unpressed_relief(self, relief: int) -> Self:
-        if relief == self.unpressed_relief:
-            return self
-        self.unpressed_relief = relief
-        self.dirty_shape = True
-        if not self.is_pressed:
-            self.set_relief(relief)
-        return self
-
-    def set_pressed_relief(self, relief: int) -> Self:
-        if relief == self.pressed_relief:
-            return self
-        self.pressed_relief = relief
-        self.dirty_shape = True
-        if self.is_pressed:
-            self.set_relief(relief)
-        return self
-
-    def set_silent_focus(self, value: bool) -> Self:
-        self.silent_focus = value
-        return self
-
-    def set_click_down_sound(self, sound_name: str) -> Self:
-        self.click_down_sound = sound_name
-        return self
-
-    def set_click_up_sound(self, sound_name: str) -> Self:
-        self.click_up_sound = sound_name
-        return self
-
-    def set_get_focus_sound(self, sound_name: str) -> Self:
-        self.get_focus_sound = sound_name
-        return self
-
-    def set_lose_focus_sound(self, sound_name: str) -> Self:
-        self.lose_focus_sound = sound_name
-        return self
-
-    def set_hover_cursor(self, cursor: pygame.Cursor) -> Self:
-        self.hover_cursor = cursor
-        return self
-
-    def set_click_cursor(self, cursor: pygame.Cursor) -> Self:
-        self.click_cursor = cursor
-        return self
-
-    def get_surface_filter(self) -> pygame.Surface | None:
-        size = int(self.rect.w), int(self.rect.h)
-        surface_filter = ClickableWidget._cache.get((size, *self.border_radius), None)
-        if surface_filter is None:
-            # Create a mask from the original surface
-            mask = pygame.mask.from_surface(self.surface, threshold=0)
-
-            silhouette_surface = mask.to_surface(
-                setcolor=(30, 30, 30), unsetcolor=(0, 0, 0)
-            )
-
-            ClickableWidget._cache[(size, *self.border_radius)] = silhouette_surface
-
-            surface_filter = silhouette_surface
-
-        return surface_filter
-
-    def allow_focus_to_self(self) -> bool:
-        return True
-
-    def enable(self) -> Self:
-        self.enabled = True
-        self.dirty_surface = True
-        return self
-
-    def disable(self) -> Self:
-        self.enabled = False
-        self.dirty_surface = True
-        return self
-
-    def is_enabled(self) -> bool:
-        return self.enabled
-
-    def set_callback(self, callback: Callable) -> Self:
-        self.callback = callback
-        return self
-
-    def on_get_focus(self):
-        super().on_get_focus()
-        if self.get_focus_sound and not self.silent_focus:
-            if self.parent_scene and self.parent_scene.visible:
-                bf.AudioManager().play_sound(self.get_focus_sound)
-        if self.silent_focus:
-            self.silent_focus = False
-
-    def on_lose_focus(self):
-        super().on_lose_focus()
-        if self.lose_focus_sound and not self.silent_focus:
-            if self.parent_scene and self.parent_scene.visible:
-                bf.AudioManager().play_sound(self.lose_focus_sound)
-        if self.silent_focus:
-            self.silent_focus = False
-
-    def __str__(self) -> str:
-        return f"ClickableWidget"
-
-    def click(self, force=False) -> None:
-        if not self.enabled and not force:
-            return
-        if self.callback is not None:
-            self.callback()
-
-    def do_on_click_down(self, button) -> None:
-        if self.enabled and button == 1:
-            if not self.get_focus():
-                return
-            self.is_pressed = True
-            if self.click_down_sound:
-                bf.AudioManager().play_sound(self.click_down_sound)
-            pygame.mouse.set_cursor(self.click_cursor)
-            self.set_relief(self.pressed_relief)
-
-    def do_on_click_up(self, button) -> None:
-        if self.enabled and button == 1 and self.is_pressed:
-            self.is_pressed = False
-            if self.click_up_sound:
-                bf.AudioManager().play_sound(self.click_up_sound)
-            self.set_relief(self.unpressed_relief)
-            self.click()
-
-    def on_enter(self) -> None:
-        if not self.enabled:
-            return
-        super().on_enter()
-        self.dirty_surface = True
-        pygame.mouse.set_cursor(self.hover_cursor)
-
-    def on_exit(self) -> None:
-        super().on_exit()
-        if self.is_pressed:
-            self.set_relief(self.unpressed_relief)
-        self.is_pressed = False
-        self.dirty_surface = True
-
-        pygame.mouse.set_cursor(bf.const.DEFAULT_CURSOR)
-
-    def on_lose_focus(self):
-        super().on_lose_focus()
-        self.on_exit()
-
-    def on_key_down(self, key):
-        if key == pygame.K_SPACE:
-            self.on_click_down(1)
-        super().on_key_down(key)
-
-    def on_key_up(self, key):
-        if key == pygame.K_SPACE:
-            self.on_click_up(1)
-        super().on_key_up(key)
-
-    def _paint_disabled(self) -> None:
-        self.surface.blit(
-            self.get_surface_filter(), (0, 0), special_flags=pygame.BLEND_RGB_SUB
-        )
-
-    def _paint_hovered(self) -> None:
-        self.surface.blit(
-            self.get_surface_filter(), (0, 0), special_flags=pygame.BLEND_RGB_ADD
-        )
-
-    def get_padded_rect(self) -> pygame.FRect:
-        return pygame.FRect(
-            self.rect.x + self.padding[0],
-            self.rect.y
-            + self.padding[1]
-            + (self.unpressed_relief - self.pressed_relief if self.is_pressed else 0),
-            self.rect.w - self.padding[2] - self.padding[0],
-            self.rect.h - self.unpressed_relief - self.padding[1] - self.padding[3],  #
-        )
-
-    def _get_elevated_rect(self) -> pygame.FRect:
-        return pygame.FRect(
-            0,
-            self.unpressed_relief - self.pressed_relief if self.is_pressed else 0,
-            self.rect.w,
-            self.rect.h - self.unpressed_relief,
-        )
-
-    def paint(self) -> None:
-        super().paint()
-        if not self.enabled:
-            self._paint_disabled()
-        elif self.is_hovered:
-            self._paint_hovered()
- 

batFramework/gui/constraints/__init__.py

@@ -1 +0,0 @@
-from . import constraints