batframework 1.1.0__tar.gz → 2.0.0a1__tar.gz

{batframework-1.1.0 → batframework-2.0.0a1}/LICENSE

@@ -1,21 +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
+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.1.0 → batframework-2.0.0a1}/PKG-INFO

@@ -1,7 +1,8 @@
 Metadata-Version: 2.2
 Name: batframework
-Version: 1.1.0
+Version: 2.0.0a1
 Summary: Pygame framework for making games easier.
+Author-email: Turan Baturay <baturayturan@gmail.com>
 License: MIT License
         
         Copyright (c) [2023] [TURAN BATURAY]
@@ -23,6 +24,10 @@ License: MIT License
         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.
+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: LICENSE
@@ -30,7 +35,7 @@ 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.
+batFramework is a Python game framework built using Pygame, designed to simplify game development.
 
 ## Purpose and Overview
 The primary objective of batFramework is to streamline game development. It is mainly designed to program small 2D games

{batframework-1.1.0 → batframework-2.0.0a1}/README.md

@@ -1,36 +1,36 @@
-# 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. It is mainly designed to program small 2D games
-
-## 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(resolution=(1280, 720), window_caption="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
-
-For more detailed information, please refer to the [documentation](https://batframework.github.io/batDocumentation/).
-
-
-# License
- MIT License
-
-
+# batFramework
+
+batFramework is a Python game framework built using Pygame, designed to simplify game development.
+
+## Purpose and Overview
+The primary objective of batFramework is to streamline game development. It is mainly designed to program small 2D games
+
+## 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(resolution=(1280, 720), window_caption="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
+
+For more detailed information, please refer to the [documentation](https://batframework.github.io/batDocumentation/).
+
+
+# License
+ MIT License
+
+

batframework-2.0.0a1/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools==76.1.0 "]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "batframework"
+version = "2.0.0a1"
+license = { file = "LICENSE" }
+authors = [
+    { name="Turan Baturay", email="baturayturan@gmail.com" }
+]
+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.urls]
+Homepage = "https://github.com/TuranBaturay/batFramework"
+

batframework-2.0.0a1/src/batFramework/__init__.py

@@ -0,0 +1,98 @@
+import pathlib
+import tomllib
+from importlib.metadata import version, PackageNotFoundError
+
+import os
+import pygame
+import json
+import batFramework as bf
+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 .timeManager import TimeManager,Timer,SceneTimer
+from .easingController import EasingController
+from .propertyEaser import PropertyEaser
+from .cutsceneManager import CutsceneManager
+import batFramework.cutscene as cutscene
+from .audioManager import AudioManager
+import batFramework.transition as transition
+from .action import Action
+from .actionContainer import *
+from .camera import Camera
+from .entity import Entity
+from .drawable import Drawable
+from .renderGroup import RenderGroup
+from .dynamicEntity import DynamicEntity
+from .sprite import Sprite
+from .scrollingSprite import ScrollingSprite
+from .particle import *
+from .animation import Animation
+from .animatedSprite import AnimatedSprite
+from .stateMachine import State, StateMachine
+from .sceneLayer import SceneLayer
+from .scene import Scene
+from .baseScene import BaseScene
+import batFramework.gui as gui
+from .sceneManager import SceneManager
+from .manager import Manager
+from .templates import *
+
+
+
+def get_version() -> str:
+    try:
+        return version("batframework")
+    except PackageNotFoundError:
+        pyproject = pathlib.Path(__file__).resolve().parent.parent / "pyproject.toml"
+        if pyproject.exists():
+            with open(pyproject, "rb") as f:
+                data = tomllib.load(f)
+            return data["project"]["version"]
+        return "0.0.0"
+
+__version__ = get_version()
+
+def init_screen(resolution: tuple[int, int], flags: int = 0, vsync: int = 0):
+    const.set_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]}"
+    )
+
+
+def print_version():
+    print(f"BatFramework version: {__version__}")
+
+def init(
+    resolution: tuple[int, int],
+    flags: int = 0,
+    window_caption: str = "BatFramework Project",
+    resource_path: str | None = None,
+    default_font_size=None,
+    default_font=None,
+    fps_limit: int = 0,
+    vsync: int = 0,
+):
+    print_version()
+    pygame.display.set_caption(window_caption)
+    init_screen(resolution, flags, vsync)
+    pygame.mixer.init()
+    
+    ResourceManager().set_resource_path(
+        resource_path if resource_path is not None else "."
+    )
+    if resource_path is not None:
+        ResourceManager().load_resources(ResourceManager().RESOURCE_PATH)
+    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-2.0.0a1/src/batFramework/action.py

@@ -0,0 +1,280 @@
+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 __bool__(self) -> bool :
+        return self.active
+
+    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
+        
+
+    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 in self._event_control:
+            self.data = event.dict
+            self.data.update({"type":event.type})
+
+
+    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 in self._event_control:
+            self._activate_action(event.type)
+        else:
+            return
+        
+        self.data = event.dict
+        self.data.update({"type":event.type})
+
+        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 in self._event_control:
+                self._deactivate_action(event.type)
+
+            else:
+                event.consumed = False
+                return
+
+        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()
+        self.data = {}

batframework-2.0.0a1/src/batFramework/actionContainer.py

@@ -0,0 +1,105 @@
+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 __getitem__(self, key):
+        return self._actions[key]
+
+    def __setitem__(self, key, value):
+        self._actions[key] = value
+
+    def __delitem__(self, key):
+        del self._actions[key]
+
+    def __contains__(self, key):
+        return key in self._actions
+
+    def __repr__(self):
+        return repr(self._actions)
+
+
+
+    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 is_any_active(self,*names:str) -> bool:
+        return any(
+            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(),
+        )