batframework 1.0.10__tar.gz → 2.0.0a1__tar.gz

{batframework-1.0.10 → 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.0.10 → batframework-2.0.0a1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: batframework
-Version: 1.0.10
+Version: 2.0.0a1
 Summary: Pygame framework for making games easier.
 Author-email: Turan Baturay <baturayturan@gmail.com>
 License: MIT License
@@ -35,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.0.10 → 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-1.0.10 → batframework-2.0.0a1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "batframework"
-version = "1.0.10"
+version = "2.0.0a1"
 license = { file = "LICENSE" }
 authors = [
     { name="Turan Baturay", email="baturayturan@gmail.com" }
@@ -20,17 +20,6 @@ requires-python = ">=3.11"
 dependencies=[
     "pygame-ce"
 ]
-
 [project.urls]
-"Homepage" = "https://github.com/TuranBaturay/batFramework"
+Homepage = "https://github.com/TuranBaturay/batFramework"
 
-[tool.commitizen]
-name = "cz_conventional_commits"
-version_provider = "pep621"
-tag_format = "$version"
-update_changelog_on_bump = true
-changelog_file = "CHANGELOG.md"
-version_files = [
-  "pyproject.toml:version",
-  "src/batFramework/__init__.py:__version__"
-]

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