batframework 1.0.8a9__tar.gz → 1.0.8a11__tar.gz

batframework-1.0.8a11/LICENCE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [2023] [TURAN BATURAY]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

batframework-1.0.8a11/PKG-INFO

@@ -0,0 +1,43 @@
+Metadata-Version: 2.1
+Name: batframework
+Version: 1.0.8a11
+Summary: Pygame framework for making games easier.
+Author-email: Turan Baturay <baturayturan@gmail.com>
+Project-URL: Homepage, https://github.com/TuranBaturay/batFramework
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENCE
+Requires-Dist: pygame-ce
+
+# batFramework
+
+Welcome to the `batFramework`. This README provides an overview of the game framework.
+
+## batFramework
+
+The `batFramework` is a Python game development framework based on pygame, designed to streamline the process of creating 2D games. It provides a set of tools and components to handle scenes, transitions, cutscenes, audio, sprites, and more. The framework is built with flexibility in mind, allowing you to focus on game design while abstracting away low-level details.
+
+### Features
+
+- Scene management
+- Cutscene support
+- Audio management (music and sound effects with volume control)
+- Entity, sprite, and animated sprite handling
+- Transition effects
+- Utility modules (time management, constants, etc.)
+- No external dependency except for pygame
+
+###  Explore batFramework
+
+1. Install Python (version 3.11 or higher) and the latest stable version of pygame-ce.
+2. Clone or download this repository.
+4. Explore the framework's modules in the `batFramework` directory and integrate them into your own game project.
+
+For more detailed information on how to use the framework, refer to the documentation (if available) or explore the source code in the `batFramework` directory.
+
+
+
+

batframework-1.0.8a11/README.md

@@ -0,0 +1,29 @@
+# batFramework
+
+Welcome to the `batFramework`. This README provides an overview of the game framework.
+
+## batFramework
+
+The `batFramework` is a Python game development framework based on pygame, designed to streamline the process of creating 2D games. It provides a set of tools and components to handle scenes, transitions, cutscenes, audio, sprites, and more. The framework is built with flexibility in mind, allowing you to focus on game design while abstracting away low-level details.
+
+### Features
+
+- Scene management
+- Cutscene support
+- Audio management (music and sound effects with volume control)
+- Entity, sprite, and animated sprite handling
+- Transition effects
+- Utility modules (time management, constants, etc.)
+- No external dependency except for pygame
+
+###  Explore batFramework
+
+1. Install Python (version 3.11 or higher) and the latest stable version of pygame-ce.
+2. Clone or download this repository.
+4. Explore the framework's modules in the `batFramework` directory and integrate them into your own game project.
+
+For more detailed information on how to use the framework, refer to the documentation (if available) or explore the source code in the `batFramework` directory.
+
+
+
+

batframework-1.0.8a11/pyproject.toml

@@ -0,0 +1,18 @@
+[build-system]
+requires = [ "setuptools>=61.0",]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "batframework"
+version = "1.0.8a11"
+description = "Pygame framework for making games easier."
+readme = "README.md"
+classifiers = [ "Programming Language :: Python :: 3", "License :: OSI Approved :: MIT License", "Operating System :: OS Independent",]
+requires-python = ">=3.11"
+dependencies = [ "pygame-ce",]
+[[project.authors]]
+name = "Turan Baturay"
+email = "baturayturan@gmail.com"
+
+[project.urls]
+Homepage = "https://github.com/TuranBaturay/batFramework"

batframework-1.0.8a11/src/batFramework/__init__.py

@@ -0,0 +1,83 @@
+import pygame
+import batFramework as bf
+import sys
+from .constants import Constants as const
+from .utils import Singleton
+from .enums import *
+from .resourceManager import ResourceManager
+from .fontManager import FontManager
+from .utils import Utils as utils
+from .tileset import Tileset
+from .time import *
+from .easingController import EasingController
+from .cutscene import Cutscene, CutsceneManager
+from .cutsceneBlocks import *
+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 .renderGroup import RenderGroup
+from .dynamicEntity import DynamicEntity
+from .sprite import Sprite
+from .scrollingSprite import ScrollingSprite
+from .particle import *
+from .animatedSprite import AnimatedSprite, Animation
+from .character import Character
+from .stateMachine import State, StateMachine
+from .scene import Scene
+from .gui import *
+from .sceneManager import SceneManager
+from .manager import Manager
+from .templates import *
+import importlib.metadata
+
+
+def init_screen(resolution: tuple[int, int], flags: int = 0, vsync: int = 0):
+    const.RESOLUTION = resolution
+    const.FLAGS = flags
+    const.VSYNC = vsync
+    const.SCREEN = pygame.display.set_mode(
+        const.RESOLUTION, const.FLAGS, vsync=const.VSYNC
+    )
+    print(
+        f"Window : {resolution[0]}x{resolution[1]} [vsync:{pygame.display.is_vsync()}]"
+    )
+
+
+
+def print_version():
+    package_name = "batFramework"
+    try:
+        version = importlib.metadata.version(package_name)
+        print(f"{package_name} version: {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,
+    resource_path: str | None = None,
+    window_title: str = "BatFramework Project",
+    fps_limit: int = 0,
+):
+    print_version()
+    pygame.display.set_caption(window_title)
+    init_screen(resolution, flags, vsync)
+
+    ResourceManager().set_resource_path(
+        resource_path if resource_path is not None else "."
+    )
+    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)
+    FontManager().init_font(default_font)
+    const.BF_INITIALIZED = True
+    const.set_fps_limit(fps_limit)

batframework-1.0.8a11/src/batFramework/action.py

@@ -0,0 +1,279 @@
+from typing import Any, Self
+from enum import Enum
+import pygame
+from .enums import actionType
+
+
+class Action:
+    def __init__(self, name: str) -> None:
+        """
+        Create a new action with the given name.
+
+        Args:
+            name (str): The name of the action.
+        """
+        self.name: str = name
+        self.active: bool = False
+        self.data: dict = {}
+        self.consume_event: bool = False
+        self._type: actionType = actionType.INSTANTANEOUS
+        self._key_control: set = set()
+        self._mouse_control: set = set()
+        self._event_control: set = set()
+        self._gamepad_button_control: set = set()
+        self._gamepad_axis_control: set = set()
+        self._holding = set()
+
+    def set_consume_event(self, val: bool) -> Self:
+        """
+        Set whether this action is unique (exclusive).
+        When in an action Container, unique actions -when active - break the propagation of their event to other actions.
+
+        Args:
+            val (bool): True if the action is unique, False otherwise.
+        """
+        self.consume_event = val
+        return self
+
+    def set_active(self, value: bool) -> None:
+        """
+        Set the action's active state.
+
+        Args:
+            value (bool): True to activate the action, False to deactivate it.
+        """
+        self.active = value
+        # self._holding = set()
+
+    def add_event_control(self, *events) -> Self:
+        self._event_control.update(events)
+        return self
+
+    def remove_event_control(self, *events) -> Self:
+        self._event_control = self._event_control - events
+        return self
+
+    def add_key_control(self, *keys) -> Self:
+        """
+        Add key controls to the action.
+
+        Args:
+            *keys (int): Key codes to control this action.
+
+        Returns:
+            Action: The updated Action object for method chaining.
+        """
+        self._key_control.update(keys)
+        return self
+
+    def remove_key_control(self, *keys: int) -> Self:
+        """
+        Remove key controls to the action.
+
+        Args:
+            *keys (int): Key codes to control this action.
+
+        Returns:
+            Action: The updated Action object for method chaining.
+        """
+        self._key_control = self._key_control - set(keys)
+        return self
+
+    def replace_key_control(self, key, new_key) -> Self:
+        if not key in self._key_control:
+            return self
+        self.remove_key_control(key)
+        self.add_key_control(new_key)
+        return self
+
+    def add_mouse_control(self, *mouse: int) -> Self:
+        """
+        Add mouse control to the action.
+
+        Args:
+            *mouse_buttons (int): Mouse button codes to control this action.
+
+        Returns:
+            Action: The updated Action object for method chaining.
+        """
+        self._mouse_control.update(mouse)
+        return self
+
+    def remove_mouse_control(self, *mouse: int) -> Self:
+        self._mouse_control = self._mouse_control - set(mouse)
+        return self
+
+    def replace_mouse_control(self, mouse, new_mouse) -> Self:
+        if not mouse in self._mouse_control:
+            return self
+        self.remove_mouse_control(mouse)
+        self.add_mouse_control(new_mouse)
+        return self
+
+    def set_continuous(self) -> Self:
+        """
+        Set the action type to continuous.
+
+        Returns:
+            Action: The updated Action object for method chaining.
+        """
+        self._holding = set()
+        self._type = actionType.CONTINUOUS
+        return self
+
+    def is_continuous(self) -> bool:
+        """
+        Check if the action type is continuous.
+
+        Returns:
+            bool: True if the action type is continuous, False otherwise.
+        """
+        return self._type == actionType.CONTINUOUS
+
+    def set_instantaneous(self) -> Self:
+        """
+        Set the action type to instantaneous.
+
+        Returns:
+            Action: The updated Action object for method chaining.
+        """
+        self._type = actionType.INSTANTANEOUS
+        self._holding = set()
+        return self
+
+    def is_instantaneous(self) -> bool:
+        """
+        Check if the action type is instantaneous.
+
+        Returns:
+            bool: True if the action type is instantaneous, False otherwise.
+        """
+        return self._type == actionType.INSTANTANEOUS
+
+    def set_holding(self) -> Self:
+        """
+        Set the action type to holding.
+
+        Returns:
+            Action: The updated Action object for method chaining.
+        """
+        self._type = actionType.HOLDING
+        return self
+
+    def is_holding_type(self) -> bool:
+        """
+        Check if the action type is holding.
+
+        Returns:
+            bool: True if the action type is holding, False otherwise.
+        """
+        return self._type == actionType.HOLDING
+
+    def process_update(self, event: pygame.Event) -> None:
+        if (
+            event.type == pygame.MOUSEMOTION
+            and self._type == actionType.HOLDING
+            and pygame.MOUSEMOTION in self._mouse_control
+        ) or self._event_control:
+            self.data = event.dict
+
+    def process_activate(self, event: pygame.event.Event):
+        """
+        Process activation of the action based on a pygame event.
+
+        Args:
+            event (pygame.event.Event): The pygame event to process.
+
+        Returns:
+            bool: True if the action was activated by the event, False otherwise.
+        """
+
+        if event.type == pygame.KEYDOWN and event.key in self._key_control:
+            self._activate_action(event.key)
+
+        elif (
+            event.type == pygame.MOUSEBUTTONDOWN and event.button in self._mouse_control
+        ):
+            self._activate_action(event.button)
+
+        elif event.type == pygame.MOUSEMOTION and event.type in self._mouse_control:
+            self._activate_action(event.type)
+
+        elif event.type in self._event_control:
+            self._activate_action(event.type)
+            self.data = event.dict
+        else:
+            return
+        if self.consume_event:
+            event.consumed = True
+
+    def _activate_action(self, control):
+        self.active = True
+        if self._type == actionType.HOLDING:
+            self._holding.add(control)
+
+    def process_deactivate(self, event: pygame.event.Event):
+        """
+        Process deactivation of the action based on a pygame event.
+
+        Args:
+            event (pygame.event.Event): The pygame event to process.
+
+        """
+        if self._type == actionType.HOLDING:
+            if event.type == pygame.KEYUP and event.key in self._key_control:
+                self._deactivate_action(event.key)
+            elif (
+                event.type == pygame.MOUSEBUTTONUP
+                and event.button in self._mouse_control
+            ):
+                self._deactivate_action(event.button)
+            elif event.type == pygame.MOUSEMOTION and event.type in self._mouse_control:
+                self._deactivate_action(event.type)
+            elif event.type in self._event_control:
+                self._deactivate_action(event.type)
+            else:
+                event.consumed = False
+
+        if self.consume_event:
+            event.consumed = True
+
+    def _deactivate_action(self, control) -> bool:
+        if control in self._holding:
+            self._holding.remove(control)
+        if not self._holding:
+            self.active = False
+
+    def process_event(self, event: pygame.event.Event):
+        """
+        Process a pygame event and update the action's state.
+
+        Args:
+            event (pygame.event.Event): The pygame event to process.
+        """
+
+        if event.consumed:
+            return
+        if not self.active:
+            self.process_activate(event)
+        else:
+            self.process_deactivate(event)
+        if self.active:
+            self.process_update(event)
+        return
+
+    def reset(self) -> None:
+        """
+        Reset the action's state to the default state.
+        """
+        if self._type in {actionType.CONTINUOUS, actionType.HOLDING}:
+            return
+        elif self._type == actionType.INSTANTANEOUS:
+            self.active = False
+
+    def hard_reset(self) -> None:
+        """
+        Hard reset the action, deactivating it and clearing any holding controls.
+        """
+        self.active = False
+        self._holding = set()

batframework-1.0.8a11/src/batFramework/actionContainer.py

@@ -0,0 +1,82 @@
+import batFramework as bf
+import pygame
+
+
+class ActionContainer:
+    def __init__(self, *actions: list[bf.Action]) -> None:
+        self._actions: dict[str, bf.Action] = {}
+        if actions:
+            self.add_actions(*actions)
+
+    def __iter__(self):
+        return iter(self._actions.values())
+
+    def clear(self):
+        self._actions = {}
+
+    def add_actions(self, *actions: bf.Action):
+        for action in actions:
+            self._actions[action.name] = action
+
+    def get(self, name: str) -> bf.Action:
+        return self._actions.get(name)
+
+    def has_action(self, name: str):
+        return name in self._actions
+
+    def get_all(self) -> list[bf.Action]:
+        return self._actions
+
+    def is_active(self, *names: str) -> bool:
+        return all(
+            self._actions.get(name).active if name in self._actions else False
+            for name in names
+        )
+
+    def process_event(self, event):
+        if event.consumed:
+            return
+        for action in self._actions.values():
+            action.process_event(event)
+            if event.consumed == True:
+                break
+
+    def reset(self):
+        for action in self._actions.values():
+            action.reset()
+
+    def hard_reset(self):
+        for action in self._actions.values():
+            action.hard_reset()
+
+
+class DirectionalKeyControls(ActionContainer):
+    def __init__(self):
+        super().__init__(
+            bf.Action("up").add_key_control(pygame.K_UP).set_holding(),
+            bf.Action("down").add_key_control(pygame.K_DOWN).set_holding(),
+            bf.Action("left").add_key_control(pygame.K_LEFT).set_holding(),
+            bf.Action("right").add_key_control(pygame.K_RIGHT).set_holding(),
+        )
+
+
+class WASDControls(ActionContainer):
+    def __init__(self):
+        super().__init__(
+            bf.Action("up").add_key_control(pygame.K_w).set_holding(),
+            bf.Action("down").add_key_control(pygame.K_s).set_holding(),
+            bf.Action("left").add_key_control(pygame.K_a).set_holding(),
+            bf.Action("right").add_key_control(pygame.K_d).set_holding(),
+        )
+
+
+class HybridControls(ActionContainer):
+    def __init__(self):
+        super().__init__(
+            bf.Action("up").add_key_control(pygame.K_UP, pygame.K_w).set_holding(),
+            bf.Action("down").add_key_control(pygame.K_DOWN, pygame.K_s).set_holding(),
+            bf.Action("left").add_key_control(pygame.K_LEFT, pygame.K_a).set_holding(),
+            bf.Action("right")
+            .add_key_control(pygame.K_RIGHT, pygame.K_r)
+            .set_holding(),
+        )