batframework 1.0.10__tar.gz → 2.0.0__tar.gz

{batframework-1.0.10 → batframework-2.0.0}/LICENSE

@@ -18,4 +18,4 @@ 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.
+SOFTWARE.

{batframework-1.0.10 → batframework-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: batframework
-Version: 1.0.10
+Version: 2.0.0
 Summary: Pygame framework for making games easier.
 Author-email: Turan Baturay <baturayturan@gmail.com>
 License: MIT License
@@ -24,6 +24,7 @@ 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
@@ -35,7 +36,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
@@ -67,5 +68,3 @@ For more detailed information, please refer to the [documentation](https://batfr
 
 # License
  MIT License
-
-

{batframework-1.0.10 → batframework-2.0.0}/README.md

@@ -1,6 +1,6 @@
 # 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
@@ -32,5 +32,3 @@ For more detailed information, please refer to the [documentation](https://batfr
 
 # License
  MIT License
-
-

{batframework-1.0.10 → batframework-2.0.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "batframework"
-version = "1.0.10"
+version = "2.0.0"
 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.0/src/batFramework/__init__.py

@@ -0,0 +1,99 @@
+import pathlib
+import tomllib
+from importlib.metadata import version, PackageNotFoundError
+
+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()
+
+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 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.0/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.0/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(),
+        )

batframework-2.0.0/src/batFramework/animatedSprite.py

@@ -0,0 +1,81 @@
+import batFramework as bf
+import pygame
+from typing import List, Dict, Tuple, Union, Optional, Self, Callable, Any
+from .animation import Animation
+
+class AnimatedSprite(bf.Drawable):
+    def __init__(self,*args,**kwargs) -> None:
+        super().__init__((0,0),*args,**kwargs)
+        self.animations : dict[str,Animation] = {}
+        self.counter = 0 # int counter
+        self._fcounter = 0.0 # counter
+        self.current_animation : str = None
+        self.end_callback : Callable[[],Any] = None
+        self._flipX : bool = False
+        self.animation_loop : int = -1
+        self.queued_animation : str = None
+
+    @property
+    def flipX(self)->bool:
+        return self._flipX
+    
+    @flipX.setter
+    def flipX(self,value:bool):
+        self._flipX = value
+
+    def set_animation_end_callback(self,callback : Callable[[],Any]):
+        self.end_callback = callback 
+
+    def add_animation(self,animation:Animation)->Self:
+        self.animations[animation.name] = animation
+        if self.rect.size == (0,0):
+            self.rect.size = animation.frames[0].get_size()
+            self.surface = animation.frames[0].copy()
+        return self
+    
+    def set_animation(self,name:str,reset_counter:bool=True,loop:int=-1,queued_animation:str=None):
+        """
+        Sets the current animation,
+        if animation with given name hasn't been added, nothing happens
+        """
+        if name not in self.animations :
+            return
+        self.current_animation = name
+        if reset_counter:
+            self._fcounter = 0
+            self.counter = 0
+        self.animation_loop = loop
+        if loop != -1:
+            self.queued_animation = queued_animation
+        else:
+            self.queued_animation = None
+
+    def get_current_frame(self)->int|None:
+        if not self.current_animation:
+            return None
+        return  self.animations[self.current_animation].counter_to_frame(self._fcounter)        
+
+    def update(self, dt):
+        super().update(dt)        
+        if not self.current_animation:
+            return
+        self._fcounter += dt * 60 
+        self.counter = int(self._fcounter)
+        # self.counter = self.get_current_frame()
+        # print(f"{self.current_animation}:{self.counter}/{self.animations[self.current_animation].duration_list_length}")
+        if self.counter >= self.animations[self.current_animation].duration_list_length:
+            #one animation cycle ended
+            if self.animation_loop > 0:
+                self.animation_loop -= 1
+            elif self.queued_animation is not None:
+                # print("set to queued :",self.queued_animation)
+                self.set_animation(self.queued_animation,True)
+
+            if self.end_callback:
+                self.end_callback()            
+ 
+    def draw(self, camera):
+        # print(self.current_animation, f"{self.counter}/{self.animations[self.current_animation].duration_list_length}")
+        self.surface = self.animations[self.current_animation].get_frame(self.counter,self.flipX)#,(0,0)
+        super().draw(camera)
+