batframework 1.0.8a1__tar.gz → 1.0.8a2__tar.gz

batframework-1.0.8a2/PKG-INFO

@@ -0,0 +1,58 @@
+Metadata-Version: 2.1
+Name: batframework
+Version: 1.0.8a2
+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.10
+Description-Content-Type: text/markdown
+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.
+
+## Purpose and Overview
+The primary objective of batFramework is to streamline game development by utilizing entities and scenes that hold entities. It employs a manager, which inherits from the scene manager, to handle scenes, propagate events, and manage updates and rendering.
+
+## 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((1280, 720), window_title="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
+
+- Scene management for organizing game components
+- Cutscene support to facilitate storytelling sequences
+- Audio management for music and sound effects with volume control
+- Entity, sprite, and animated sprite support
+- Utility modules such as time management and easingAnimation
+
+Users can leverage these functionalities to build games efficiently using batFramework.
+
+For more detailed usage and examples, please refer to the documentation or codebase.
+
+
+# License
+ MIT License
+
+

batframework-1.0.8a2/README.md

@@ -0,0 +1,45 @@
+# 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 by utilizing entities and scenes that hold entities. It employs a manager, which inherits from the scene manager, to handle scenes, propagate events, and manage updates and rendering.
+
+## 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((1280, 720), window_title="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
+
+- Scene management for organizing game components
+- Cutscene support to facilitate storytelling sequences
+- Audio management for music and sound effects with volume control
+- Entity, sprite, and animated sprite support
+- Utility modules such as time management and easingAnimation
+
+Users can leverage these functionalities to build games efficiently using batFramework.
+
+For more detailed usage and examples, please refer to the documentation or codebase.
+
+
+# License
+ MIT License
+
+

{batframework-1.0.8a1 → batframework-1.0.8a2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "batframework"
-version = "1.0.8a1"
+version = "1.0.8a2"
 authors = [
     { name="Turan Baturay", email="baturayturan@gmail.com" }
 ]
@@ -15,7 +15,7 @@ classifiers = [
     "License :: OSI Approved :: MIT License",
     "Operating System :: OS Independent",
 ]
-requires-python = ">=3.11"
+requires-python = ">=3.10"
 dependencies=[
     "pygame-ce"
 ]

batframework-1.0.8a2/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.0.8a2/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.0.8a2/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.0.8a2/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.0.8a2/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()