batframework 0.1.13__tar.gz → 1.0.1__tar.gz

batframework-1.0.1/LICENCE

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

{batframework-0.1.13 → batframework-1.0.1}/PKG-INFO

@@ -1,14 +1,15 @@
 Metadata-Version: 2.1
 Name: batframework
-Version: 0.1.13
+Version: 1.0.1
 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
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
+License-File: LICENCE
 Requires-Dist: pygame-ce
 
 # batFramework & gamejam Project

{batframework-0.1.13 → batframework-1.0.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "batframework"
-version = "0.1.13"
+version = "1.0.1"
 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.10"
+requires-python = ">=3.11"
 dependencies=[
     "pygame-ce"
 ]

batframework-1.0.1/src/batFramework/__init__.py

@@ -0,0 +1,62 @@
+import pygame
+import batFramework as bf
+import sys
+from .constants import Constants as const
+from .constants import Colors as color
+from .utils import Singleton
+from .enums import *
+from .resourceManager import ResourceManager
+from .fontManager import FontManager
+# if const.BF_INITIALIZED:     
+from .utils import Utils as utils
+from .tileset import Tileset
+from .time import TimeManager, Timer
+from .cutscene import Cutscene, CutsceneManager
+from .cutsceneBlocks import *
+from .easing import Easing, EasingAnimation
+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 .dynamicEntity import DynamicEntity
+from .sprite import Sprite
+from .animatedSprite import AnimatedSprite, AnimState
+from .stateMachine import State, StateMachine
+# from .debugger import Debugger
+from .scene import Scene
+from .gui import * 
+from .sceneManager import SceneManager
+from .manager import Manager
+
+            
+def init_screen(resolution: tuple[int, int], flags: int = 0, vsync: int = 0):
+    const.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]} [vsync:{pygame.display.is_vsync()}]"
+    )
+
+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):
+        pygame.display.set_caption(window_title)
+        init_screen(resolution,flags,vsync)
+        
+        ResourceManager().set_resource_path(resource_path if resource_path is not None else ".")
+        ResourceManager().load_dir(ResourceManager().RESOURCE_PATH)
+        if default_text_size is not None : FontManager().set_default_text_size(default_text_size)
+        FontManager().init_font(default_font)
+        const.BF_INITIALIZED = True
+        const.set_fps_limit(fps_limit)

{batframework-0.1.13 → batframework-1.0.1}/src/batFramework/action.py

@@ -12,20 +12,21 @@ class Action:
         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._name :str= name
+        self._active :bool= False
+        self._type :ActionType = ActionType.INSTANTANEOUS
+        self._key_control : set= set()       
+        self._mouse_control :set = set()
+        self._gamepad_button_control :set = set()
+        self._gamepad_axis_control :set = set()
         self._holding = set()
         self._unique = True
-        self.data : Any = None
+        self.data: Any = None
 
     def set_unique(self, val: bool) -> None:
         """
         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.
@@ -51,7 +52,7 @@ class Action:
         self._active = value
         self._holding = set()
 
-    def add_key_control(self, *keys) -> 'Action':
+    def add_key_control(self, *keys) -> "Action":
         """
         Add key controls to the action.
 
@@ -64,7 +65,26 @@ class Action:
         self._key_control.update(keys)
         return self
 
-    def add_mouse_control(self, *mouse_buttons) -> 'Action':
+    def remove_key_control(self, *keys:int) -> "Action":
+        """
+        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) -> "Action":
+        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_buttons:int) -> "Action":
         """
         Add mouse control to the action.
 
@@ -86,7 +106,7 @@ class Action:
         """
         return self._name
 
-    def set_continuous(self) -> 'Action':
+    def set_continuous(self) -> "Action":
         """
         Set the action type to continuous.
 
@@ -106,7 +126,7 @@ class Action:
         """
         return self._type == ActionType.CONTINUOUS
 
-    def set_instantaneous(self) -> 'Action':
+    def set_instantaneous(self) -> "Action":
         """
         Set the action type to instantaneous.
 
@@ -126,7 +146,7 @@ class Action:
         """
         return self._type == ActionType.INSTANTANEOUS
 
-    def set_holding(self) -> 'Action':
+    def set_holding(self) -> "Action":
         """
         Set the action type to holding.
 
@@ -145,9 +165,14 @@ class Action:
         """
         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_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:
         """
@@ -205,10 +230,7 @@ class Action:
                 if not self._holding:
                     self._active = False
                     return True
-            elif (
-                event.type == pygame.MOUSEMOTION
-                and event.type in self._mouse_control
-            ):
+            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)

batframework-1.0.1/src/batFramework/actionContainer.py

@@ -0,0 +1,77 @@
+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_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 get_all(self) -> list[bf.Action]:
+        return 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()
+
+
+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-0.1.13 → batframework-1.0.1}/src/batFramework/animatedSprite.py

@@ -2,7 +2,6 @@ import batFramework as bf
 import pygame
 
 
-
 def search_index(target, lst):
     cumulative_sum = 0
     for index, value in enumerate(lst):
@@ -13,12 +12,14 @@ def search_index(target, lst):
 
 
 class AnimState:
-    def __init__(self,name:str, file, width, height, frame_length_list:list|int) -> None:
+    def __init__(
+        self, name: str, 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.name= name
+        self.name = name
         self.frame_length_list = []
         self.ffl_length = 0
         self.set_frame_length_list(frame_length_list)
@@ -26,34 +27,33 @@ class AnimState:
     def __repr__(self):
         return f"AnimState({self.name})"
 
-    def get_frame_index(self, counter:float|int):
+    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):
+    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) : 
+        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.current_animState: str = ""
         self.flipX = False
         self._locked = False
 
-    def set_counter(self,value:float):
+    def set_counter(self, value: float):
         self.float_counter = value
-        
 
     def lock_animState(self):
         self._locked = True
@@ -64,20 +64,25 @@ class AnimatedSprite(bf.DynamicEntity):
     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 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(name,file, *size, frame_length_list)
-        if len(self.animStates) == 1 : self.set_animState(name)
+        self.animStates[name] = AnimState(name, 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):
+    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
@@ -95,7 +100,7 @@ class AnimatedSprite(bf.DynamicEntity):
         return True
 
     def get_state(self):
-        return self.animStates.get(self.current_animState,None)
+        return self.animStates.get(self.current_animState, None)
 
     def get_frame_index(self):
         return self.animStates[self.current_animState].get_frame_index(
@@ -103,7 +108,8 @@ class AnimatedSprite(bf.DynamicEntity):
         )
 
     def update(self, dt: float):
-        if not self.animStates : return
+        if not self.animStates:
+            return
         self.float_counter += 60 * dt
         if self.float_counter > self.get_state().ffl_length:
             self.float_counter = 0

batframework-1.0.1/src/batFramework/camera.py

@@ -0,0 +1,253 @@
+import pygame
+from pygame.math import Vector2
+import math
+import batFramework as bf
+
+
+class Camera:
+    _transform_cache = {}  # Cache for transformed surfaces
+
+    def __init__(self, flags=0, size: tuple[int,int] | None = None,convert_alpha:bool=False) -> None:
+        """
+        Initialize the Camera object.
+
+        Args:
+            flags (int): Flags for camera initialization.
+            size (tuple): Optional size for camera (defaults to window size)
+        """
+        # Initialize camera attributes
+        size = size if size else bf.const.RESOLUTION
+        self.rect = pygame.Rect(0, 0, *size)
+        self.flags: int = flags
+        self.blit_special_flags: int = pygame.BLEND_ALPHA_SDL2
+        self._clear_color: pygame.Color = pygame.Color(0, 0, 0, 0)
+        self.zoom_factor = 1
+        self.cached_surfaces: dict[float, pygame.Surface] = {}
+        self.surface: pygame.Surface = pygame.Surface((0, 0))
+        if convert_alpha : 
+            self.surface = self.surface.convert_alpha()
+        else:
+            self.surface = self.surface.convert()
+        self.follow_point_func = None
+        self.max_zoom = 2
+        self.min_zoom = 0.1
+        self.zoom(1)
+
+    def set_clear_color(self, color: pygame.Color | tuple | str) -> "Camera":
+        """
+        Set the clear color for the camera surface.
+
+        Args:
+            color (pygame.Color | tuple): Color to set as the clear color.
+
+        Returns:
+            Camera: Returns the Camera object.
+        """
+        if not isinstance(color, pygame.Color):
+            color = pygame.Color(color)
+        self._clear_color = color
+        return self
+
+    def set_max_zoom(self, value: float) -> "Camera":
+        """
+        Set the maximum zoom value for the camera.
+
+        Args:
+            value (float): Maximum zoom value.
+
+        Returns:
+            Camera: Returns the Camera object.
+        """
+        self.max_zoom = value
+        return self
+
+    def set_min_zoom(self, value: float) -> "Camera":
+        """
+        Set the minimum zoom value for the camera.
+
+        Args:
+            value (float): Minimum zoom value.
+
+        Returns:
+            Camera: Returns the Camera object.
+        """
+        self.min_zoom = value
+        return self
+
+    def clear(self) -> None:
+        """
+        Clear the camera surface with the set clear color.
+        """
+        self.surface.fill(self._clear_color)
+
+    def get_center(self) -> tuple[float,float]:
+        """
+        Get the center of the camera's view.
+
+        Returns:
+            Vector2: Returns the center coordinates.
+        """
+        return self.rect.center
+
+    def move(self, x, y) -> "Camera":
+        """
+        Moves the camera rect by the given coordinates.
+
+        Args:
+            x: X-coordinate to move.
+            y: Y-coordinate to move.
+
+        Returns:
+            Camera: Returns the Camera object.
+        """
+        self.rect.topleft += Vector2(x, y)
+        return self
+
+    def set_position(self, x, y) -> "Camera":
+        """
+        Set the camera rect top-left position.
+
+        Args:
+            x: X-coordinate to set.
+            y: Y-coordinate to set.
+
+        Returns:
+            Camera: Returns the Camera object.
+        """
+        self.rect.topleft = (x, y)
+        return self
+
+    def set_center(self, x, y) -> "Camera":
+        """
+        Set the camera rect center position.
+
+        Args:
+            x: X-coordinate for the center.
+            y: Y-coordinate for the center.
+
+        Returns:
+            Camera: Returns the Camera object.
+        """
+        self.rect.center = (x, y)
+        return self
+
+    def set_follow_point(self, func) -> "Camera":
+        """
+        Set the following function (returns tuple x y).
+        Camera will center its position to the center of the given coordinates.
+
+        Args:
+            func: Function returning coordinates to follow.
+
+        Returns:
+            Camera: Returns the Camera object.
+        """
+        self.follow_point_func = func
+        return self
+
+    def zoom_by(self, amount: float) -> "Camera":
+        """
+        Zooms the camera by the given amount.
+
+        Args:
+            amount (float): Amount to zoom.
+
+        Returns:
+            Camera: Returns the Camera object.
+        """
+        self.zoom(self.zoom_factor + amount)
+        return self
+
+    def zoom(self, factor) -> "Camera":
+        """
+        Zooms the camera to the given factor.
+
+        Args:
+            factor: Factor to set for zooming.
+
+        Returns:
+            Camera: Returns the Camera object.
+        """
+        if factor < self.min_zoom or factor > self.max_zoom:
+            return self
+
+        factor = round(factor, 2)
+        self.zoom_factor = factor
+
+        if factor not in self.cached_surfaces:
+            self.cached_surfaces[factor] = pygame.Surface(
+                tuple(i / factor for i in bf.const.RESOLUTION), flags=self.flags
+            ).convert_alpha()
+            self.cached_surfaces[factor].fill((0, 0, 0, 0))
+
+        self.surface = self.cached_surfaces[self.zoom_factor]
+        self.rect = self.surface.get_rect(center=self.rect.center)
+        return self
+
+    def intersects(self, rect: pygame.Rect | pygame.FRect) -> bool:
+        """
+        Check if the camera view intersects with the given rectangle.
+
+        Args:
+            rect (pygame.Rect | pygame.FRect): Rectangle to check intersection with.
+
+        Returns:
+            bool: True if intersection occurs, False otherwise.
+        """
+        return (
+            self.rect.x < rect.right
+            and self.rect.right > rect.x
+            and self.rect.y < rect.bottom
+            and self.rect.bottom > rect.y
+        )
+
+    def transpose(self, rect: pygame.Rect | pygame.FRect) -> pygame.Rect | pygame.FRect:
+        """
+        Transpose the given rectangle coordinates relative to the camera.
+
+        Args:
+            rect (pygame.Rect | pygame.FRect): Rectangle to transpose.
+
+        Returns:
+            pygame.FRect: Transposed rectangle.
+        """
+        return pygame.FRect(rect.x - self.rect.left, rect.y - self.rect.top, *rect.size)
+
+    def convert_screen_to_world(self, x, y):
+        """
+        Convert screen coordinates to world coordinates based on camera settings.
+
+        Args:
+            x: X-coordinate in screen space.
+            y: Y-coordinate in screen space.
+
+        Returns:
+            tuple: Converted world coordinates.
+        """
+        return x / self.zoom_factor + self.rect.x, y / self.zoom_factor + self.rect.y
+
+    def update(self, dt):
+        """
+        Update the camera position based on the follow point function.
+
+        Args:
+            dt: Time delta for updating the camera position.
+        """
+        if self.follow_point_func:
+            target = self.follow_point_func()
+            self.rect.center = Vector2(self.rect.center).lerp(target, ((dt * 60) * 0.1))
+
+    def draw(self, surface: pygame.Surface):
+        """
+        Draw the camera view onto the provided surface with proper scaling.
+
+        Args:
+            surface (pygame.Surface): Surface to draw the camera view onto.
+        """
+        if self.zoom_factor == 1:
+            surface.blit(self.surface, (0, 0), special_flags=self.blit_special_flags)
+            return
+
+        # Scale the surface to match the resolution
+        scaled_surface = pygame.transform.scale(self.surface, bf.const.RESOLUTION)
+        surface.blit(scaled_surface, (0, 0), special_flags=self.blit_special_flags)