batframework 1.0.9a10__tar.gz → 1.1.0__tar.gz

{batframework-1.0.9a10 → batframework-1.1.0}/PKG-INFO

@@ -1,8 +1,7 @@
 Metadata-Version: 2.2
 Name: batframework
-Version: 1.0.9a10
+Version: 1.1.0
 Summary: Pygame framework for making games easier.
-Author-email: Turan Baturay <baturayturan@gmail.com>
 License: MIT License
         
         Copyright (c) [2023] [TURAN BATURAY]
@@ -24,10 +23,6 @@ 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
@@ -35,30 +30,37 @@ Requires-Dist: pygame-ce
 
 # batFramework
 
-Welcome to the `batFramework`. This README provides an overview of the game framework.
+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
+## Purpose and Overview
+The primary objective of batFramework is to streamline game development. It is mainly designed to program small 2D games
 
-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.
+## Installation and Setup
+To install batFramework, you can use pip:
+```pip install batFramework```
 
-### Features
+The only dependency required is pygame-ce.
 
-- 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
+## Usage Instructions
+To create a basic app using batFramework, here's an example:
 
-###  Explore batFramework
+```python
+import batFramework as bf
 
-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.
+# Initialize the framework
+bf.init(resolution=(1280, 720), window_caption="My Amazing Program")
 
-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.
+# 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.1.0/README.md

@@ -0,0 +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-1.1.0/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools==76.1.0 "]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "batframework"
+description = "Pygame framework for making games easier."
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = ["pygame-ce"]
+version = "1.1.0"
+license = { file = "LICENSE" }
+
+[tool.commitizen]
+name = "cz_conventional_commits"
+version = "1.1.0"
+tag_format = "v$version"
+update_changelog_on_bump = true
+changelog_file = "CHANGELOG.md"
+version_files = [
+  "src/batFramework/version.json:version",
+  "pyproject.toml:version"
+]

batframework-1.1.0/src/batFramework/__init__.py

@@ -0,0 +1,66 @@
+import pygame
+from .constants import Constants as const
+import os
+import json
+initialized = False
+
+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
+    ):
+    global initialized
+    if not initialized:
+        pygame.init()
+        pygame.display.set_caption(window_title)
+
+        # Initialize display
+        const.init_screen(resolution,flags,vsync)
+        const.set_fps_limit(fps_limit)
+
+        # Initialize default text size
+        if default_text_size: const.set_default_text_size(default_text_size)
+        # Initialize resource path for game data
+        if resource_path: const.set_resource_path(resource_path)
+
+        # Initialize default font cache
+        from .utils import Utils
+        if default_font is None or isinstance(default_font,str):
+            Utils.init_font(default_font)
+        else:
+            raise ValueError(f"default_font '{default_font}' can be either string or None")
+        
+        f = list(Utils.FONTS[None].values())[0]
+        print(f"Set default font to : {f.name} {'' if default_font is not None else '(default value)'}")
+        initialized = True
+
+from .constants import Colors as color
+from .constants import Axis as axis
+from .utils import Singleton
+from .utils import Utils as utils
+from .time import Time, Timer
+from .cutscene import Cutscene,CutsceneManager
+from .cutsceneBlocks import *
+from .easing import Easing, EasingAnimation
+from .audioManager import AudioManager
+from .utils import Layout, Alignment, Direction
+from .transition import *
+from .action import Action
+from .actionContainer import ActionContainer
+from .camera import Camera
+from .entity import Entity
+from .dynamicEntity import DynamicEntity
+from .animatedSprite import AnimatedSprite, AnimState
+from .stateMachine import State, StateMachine
+from .particles import Particle, ParticleManager
+# from .debugger import Debugger
+from .scene import Scene
+from .gui import * 
+from .sceneManager import SceneManager
+from .manager import Manager
+

batframework-1.1.0/src/batFramework/action.py

@@ -0,0 +1,252 @@
+from typing import Any
+from enum import Enum
+import pygame
+
+ActionType = Enum("type", "INSTANTANEOUS CONTINUOUS HOLDING")
+
+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 = name
+        self._active = False
+        self._type = ActionType.INSTANTANEOUS
+        self._key_control = set()
+        self._mouse_control = set()
+        self._gamepad_button_control = set()
+        self._gamepad_axis_control = set()
+        self._holding = set()
+        self._unique = True
+        self.data : Any = None
+
+    def set_unique(self, val: bool) -> None:
+        """
+        Set whether this action is unique (exclusive).
+
+        Args:
+            val (bool): True if the action is unique, False otherwise.
+        """
+        self._unique = val
+
+    def is_active(self) -> bool:
+        """
+        Check if the action is currently active.
+
+        Returns:
+            bool: True if the action is active, False otherwise.
+        """
+        return self._active
+
+    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_key_control(self, *keys) -> 'Action':
+        """
+        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 add_mouse_control(self, *mouse_buttons) -> 'Action':
+        """
+        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_buttons)
+        return self
+
+    def get_name(self) -> str:
+        """
+        Get the name of the action.
+
+        Returns:
+            str: The name of the action.
+        """
+        return self._name
+
+    def set_continuous(self) -> 'Action':
+        """
+        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) -> 'Action':
+        """
+        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) -> 'Action':
+        """
+        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 self.is_active() and event.type == pygame.MOUSEMOTION and  self.is_holding_type() and pygame.MOUSEMOTION in self._mouse_control:
+            self.data = {"pos":event.pos,"rel":event.rel}
+
+    def process_activate(self, event: pygame.event.Event) -> bool:
+        """
+        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._active = True
+            if self.is_holding_type():
+                self._holding.add(event.key)
+            return True
+
+        if event.type == pygame.MOUSEBUTTONDOWN and event.button in self._mouse_control:
+            self._active = True
+            if self.is_holding_type():
+                self._holding.add(event.button)
+            return True
+
+        if event.type == pygame.MOUSEMOTION and event.type in self._mouse_control:
+            self._active = True
+            if self.is_holding_type():
+                self._holding.add(event.type)
+            return True
+
+        return False
+
+    def process_deactivate(self, event: pygame.event.Event) -> bool:
+        """
+        Process deactivation 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 deactivated by the event, False otherwise.
+        """
+        if self._type == ActionType.HOLDING:
+            if event.type == pygame.KEYUP and event.key in self._key_control:
+                if event.key in self._holding:
+                    self._holding.remove(event.key)
+                if not self._holding:
+                    self._active = False
+                    return True
+            elif (
+                event.type == pygame.MOUSEBUTTONUP
+                and event.button in self._mouse_control
+            ):
+                if event.button in self._holding:
+                    self._holding.remove(event.button)
+                if not self._holding:
+                    self._active = False
+                    return True
+            elif (
+                event.type == pygame.MOUSEMOTION
+                and event.type in self._mouse_control
+            ):
+                self.value = None
+                if event.type in self._holding:
+                    self._holding.remove(event.type)
+                if not self._holding:
+                    self._active = False
+                    return True
+
+        return False
+
+    def process_event(self, event: pygame.event.Event) -> bool:
+        """
+        Process a pygame event and update the action's state.
+
+        Args:
+            event (pygame.event.Event): The pygame event to process.
+
+        Returns:
+            bool: True if the action state changed, False otherwise.
+        """
+        if not self._active:
+            res = self.process_activate(event)
+        else:
+            res = self.process_deactivate(event)
+        self.process_update(event)
+        return res
+
+    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.1.0/src/batFramework/actionContainer.py

@@ -0,0 +1,38 @@
+import batFramework as bf
+
+
+class ActionContainer:
+    def __init__(self, *actions: list[bf.Action]) -> None:
+        self._actions: dict[str, bf.Action] = {}
+        if actions:
+            self.add_action(*actions)
+
+    def clear(self):
+        self._actions = {}
+
+    def add_action(self, *actions: bf.Action):
+        for action in actions:
+            self._actions[action.get_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 is_active(self, *names:str)->bool:
+        return all(self._actions.get(name).is_active() if name in self._actions else False for name in names)
+
+    def process_event(self, event):
+        for action in self._actions.values():
+            a = action.process_event(event)
+            if a and action._unique:
+                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()

batframework-1.1.0/src/batFramework/animatedSprite.py

@@ -0,0 +1,117 @@
+import batFramework as bf
+import pygame
+
+
+
+def search_index(target, lst):
+    cumulative_sum = 0
+    for index, value in enumerate(lst):
+        cumulative_sum += value
+        if cumulative_sum >= target:
+            return index
+    return -1
+
+
+class AnimState:
+    def __init__(self, file, width, height, frame_length_list:list|int) -> None:
+        self.frames: list[pygame.Surface] = bf.utils.img_slice(file, width, height)
+        self.frames_flipX: list[pygame.Surface] = bf.utils.img_slice(
+            file, width, height, True
+        )
+
+        self.frame_length_list = []
+        self.ffl_length = 0
+        self.set_frame_length_list(frame_length_list)
+
+    def get_frame_index(self, counter:float|int):
+        return search_index(int(counter % self.ffl_length), self.frame_length_list)
+
+    def get_frame(self, counter, flip):
+        i = self.get_frame_index(counter)
+        return self.frames_flipX[i] if flip else self.frames[i]
+
+    def set_frame_length_list(self,frame_length_list:list[int]|int):
+        if isinstance(frame_length_list,int):
+            frame_length_list = [frame_length_list] * len(self.frames)
+        if len(frame_length_list) != len(self.frames) : 
+            raise ValueError("frame_length_list should have values for all frames")
+        self.frame_length_list = frame_length_list
+        self.ffl_length = sum(self.frame_length_list)
+        
+
+class AnimatedSprite(bf.DynamicEntity):
+    def __init__(self, size=None) -> None:
+        super().__init__(size, no_surface=True)
+        self.float_counter = 0
+        self.animStates: dict[str, AnimState] = {}
+        self.current_animState :str = ""
+        self.flipX = False
+        self._locked = False
+
+    def set_counter(self,value:float):
+        self.float_counter = value
+        
+
+    def lock_animState(self):
+        self._locked = True
+
+    def unlock_animState(self):
+        self._locked = False
+
+    def set_flipX(self, value):
+        self.flipX = value
+
+    def remove_animState(self, name:str):
+        if not name in self.animStates :return
+        self.animStates.pop(name) 
+        if self.current_animState == name : self.current_animState = list(self.animStates.keys())[0] if self.animStates else "" 
+
+    def add_animState(
+        self, name: str, file: str, size: tuple[int, int], frame_length_list: list[int]
+    ):
+        if name in self.animStates:
+            return
+        self.animStates[name] = AnimState(file, *size, frame_length_list)
+        if len(self.animStates) == 1 : self.set_animState(name)
+
+    def set_animState(self, state:str, reset_counter=True, lock=False):
+        if state not in self.animStates or self._locked:
+            return False
+        self.current_animState = state
+        self.rect = (
+            self.animStates[self.current_animState]
+            .frames[0]
+            .get_frect(center=self.rect.center)
+        )
+        if reset_counter or self.float_counter > sum(
+            self.get_state().frame_length_list
+        ):
+            self.float_counter = 0
+        if lock:
+            self.lock_animState()
+        return True
+
+    def get_state(self):
+        return self.animStates.get(self.current_animState,None)
+
+    def get_frame_index(self):
+        return self.animStates[self.current_animState].get_frame_index(
+            self.float_counter
+        )
+
+    def update(self, dt: float):
+        if not self.animStates : return
+        self.float_counter += 60 * dt
+        if self.float_counter > self.get_state().ffl_length:
+            self.float_counter = 0
+        self.do_update(dt)
+
+    def draw(self, camera: bf.Camera) -> bool:
+        if not self.visible or not camera.intersects(self.rect) or not self.animStates:
+            return False
+        # pygame.draw.rect(camera.surface,"purple",camera.transpose(self.rect).move(2,2))
+        camera.surface.blit(
+            self.get_state().get_frame(self.float_counter, self.flipX),
+            camera.transpose(self.rect),
+        )
+        return True

batframework-1.1.0/src/batFramework/audioManager.py

@@ -0,0 +1,85 @@
+import batFramework as bf
+import pygame
+
+pygame.mixer.init()
+
+
+class AudioManager(metaclass=bf.Singleton):
+    def __init__(self):
+        self.sounds: dict[str : dict[str, pygame.mixer.Sound, bool]] = {}
+        self.musics: dict[str:str] = {}
+        self.current_music = None
+        self.music_volume = 1
+        self.sound_volume = 1
+        pygame.mixer_music.set_endevent(bf.const.MUSIC_END_EVENT)
+
+    def free_sounds(self, force=False):
+        if force:
+            self.sounds = {}
+            return
+        to_remove = []
+        for name, data in self.sounds.items():
+            if not data["persistent"]:
+                to_remove.append(name)
+
+        _ = [self.sounds.pop(i) for i in to_remove]
+
+    def set_sound_volume(self, volume: float):
+        self.sound_volume = volume
+
+    def set_music_volume(self, volume: float):
+        self.music_volume = volume
+        pygame.mixer_music.set_volume(volume)
+
+    def has_sound(self, name):
+        return name in self.sounds
+
+    def load_sound(self, name, path, persistent=False) -> pygame.mixer.Sound:
+        if name in self.sounds:
+            return self.sounds[name]["sound"]
+        path = bf.utils.get_path(path)
+        self.sounds[name] = {
+            "path": path,
+            "sound": pygame.mixer.Sound(path),
+            "persistent": persistent,
+        }
+        return self.sounds[name]["sound"]
+
+    def play_sound(self, name, volume=1):
+        self.sounds[name]["sound"].set_volume(volume * self.sound_volume)
+        self.sounds[name]["sound"].play()
+
+    def stop_sound(self, name):
+        if name in self.sounds:
+            self.sounds[name]["sound"].stop()
+
+    def load_music(self, name, path):
+        self.musics[name] = bf.utils.get_path(path)
+
+    def play_music(self, name, loop=0, fade=500):
+        if name in self.musics:
+            pygame.mixer_music.load(self.musics[name])
+            pygame.mixer_music.play(loop, fade_ms=fade)
+            self.current_music = name
+        else:
+            print(f"Music '{name}' not found in AudioManager.")
+
+    def stop_music(self):
+        if not self.current_music:
+            return
+        pygame.mixer_music.stop()
+
+    def fadeout_music(self, fade_ms: int):
+        if not self.current_music:
+            return
+        pygame.mixer_music.fadeout(fade_ms)
+
+    def pause_music(self):
+        if not self.current_music:
+            return
+        pygame.mixer_music.pause()
+
+    def resume_music(self):
+        if not self.current_music:
+            return
+        pygame.mixer_music.unpause()