batframework 1.0.9a7__tar.gz → 1.0.9a9__tar.gz

{batframework-1.0.9a7 → batframework-1.0.9a9}/PKG-INFO

@@ -1,15 +1,36 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: batframework
-Version: 1.0.9a7
+Version: 1.0.9a9
 Summary: Pygame framework for making games easier.
 Author-email: Turan Baturay <baturayturan@gmail.com>
+License: 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.
 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: LICENCE
+License-File: LICENSE
 Requires-Dist: pygame-ce
 
 # batFramework

batframework-1.0.9a9/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools==76.1.0 "]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "batframework"
+version = "1.0.9a9"
+license = { file = "LICENSE" }
+authors = [
+    { name="Turan Baturay", email="baturayturan@gmail.com" }
+]
+description = "Pygame framework for making games easier."
+readme = "README.md"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+requires-python = ">=3.11"
+dependencies=[
+    "pygame-ce"
+]
+
+[project.urls]
+"Homepage" = "https://github.com/TuranBaturay/batFramework"

{batframework-1.0.9a7 → batframework-1.0.9a9}/src/batFramework/__init__.py

@@ -1,4 +1,6 @@
+import os
 import pygame
+import json
 import batFramework as bf
 from .constants import Constants as const
 from .utils import Singleton
@@ -9,8 +11,9 @@ 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
-from .cutscene import *
+import batFramework.cutscene as cutscene
 from .audioManager import AudioManager
 import batFramework.transition as transition
 from .action import Action
@@ -25,18 +28,18 @@ from .scrollingSprite import ScrollingSprite
 from .particle import *
 from .animation import Animation
 from .animatedSprite import AnimatedSprite
-from .character import Character
 from .stateMachine import State, StateMachine
+from .sceneLayer import SceneLayer
 from .scene import Scene
-from  .gui import *
+from .baseScene import BaseScene
+import batFramework.gui as gui
 from .sceneManager import SceneManager
 from .manager import Manager
 from .templates import *
-import importlib.metadata
 
 
 def init_screen(resolution: tuple[int, int], flags: int = 0, vsync: int = 0):
-    const.RESOLUTION = resolution
+    const.set_resolution(resolution)
     const.FLAGS = flags
     const.VSYNC = vsync
     const.SCREEN = pygame.display.set_mode(
@@ -46,13 +49,19 @@ def init_screen(resolution: tuple[int, int], flags: int = 0, vsync: int = 0):
         f"Window : {resolution[0]}x{resolution[1]}"
     )
 
+
 def print_version():
-    package_name = "batFramework"
+    # Dynamically construct the path to version.json
+    version_file = os.path.join(os.path.dirname(__file__), "version.json")
     try:
-        version = importlib.metadata.version(package_name)
-        print(f"{package_name} version: {version}")
-    except importlib.metadata.PackageNotFoundError:
-        print(f"{package_name} is not installed")
+        with open(version_file, "r") as f:
+            version_data = json.load(f)
+            version = version_data.get("version", "unknown")
+            print(f"BatFramework version: {version}")
+    except FileNotFoundError:
+        print(f"Version file not found: {version_file}")
+    except json.JSONDecodeError:
+        print(f"Error decoding version file: {version_file}")
 
 def init(
     resolution: tuple[int, int],
@@ -73,7 +82,7 @@ def init(
         resource_path if resource_path is not None else "."
     )
     if resource_path is not None:
-        ResourceManager().load_dir(ResourceManager().RESOURCE_PATH)
+        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)

{batframework-1.0.9a7 → batframework-1.0.9a9}/src/batFramework/action.py

@@ -43,7 +43,7 @@ class Action:
             value (bool): True to activate the action, False to deactivate it.
         """
         self.active = value
-        # self._holding = set()
+        
 
     def add_event_control(self, *events) -> Self:
         self._event_control.update(events)

batframework-1.0.9a9/src/batFramework/animatedSprite.py

@@ -0,0 +1,59 @@
+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__(None, no_surface=True,*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 
+
+    @property
+    def flipX(self)->bool:
+        return self._flipX
+    
+    @flipX.setter
+    def flipX(self,value:bool):
+        self._flipX = value
+
+    def set_end_callback(self,callback : Callable[[],Any]):
+        self.end_callback = callback 
+
+    def add_animation(self,name:str,animation:Animation)->Self:
+        self.animations[name] = animation
+        if self.rect.size == (0,0):
+            self.rect.size = animation.frames[0].get_size()
+        return self
+    
+    def set_animation(self,name:str,reset_counter:bool=True):
+        if name not in self.animations :
+            raise ValueError
+        self.current_animation = name
+        if reset_counter:
+            self._fcounter = 0
+
+    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
+        self.counter = int(self._fcounter)
+        if self.counter >= self.animations[self.current_animation].numFrames:
+            if self.end_callback:
+                self.end_callback()
+            
+
+    def draw(self, camera):
+        self.surface.blit(self.animations[self.current_animation].get_frame(self.counter,self.flipX),(0,0))
+        super().draw(camera)
+        

batframework-1.0.9a9/src/batFramework/animation.py

@@ -0,0 +1,77 @@
+import pygame
+import batFramework as bf
+from typing import List, Dict, Tuple, Union, Optional, Self
+
+
+def search_index(target: int, lst: List[int]) -> int:
+    cumulative_sum = 0
+    for index, value in enumerate(lst):
+        cumulative_sum += value
+        if cumulative_sum >= target:
+            return index
+    return -1
+
+
+class Animation:
+    def __init__(
+        self,
+        name: str
+    ) -> None:
+        """
+        Class to hold 2D animation data.
+        All frames are expected to have the same size.
+        This class does not do anything on its own, but can be used to easily manage
+        multiple animations using a simple counter.
+        The duration list provides a entry point for tweaking the timings,
+        so image data can be saved (no need for contiguous duplicate frames)
+        """
+        self.name = name
+        self.frames: list[pygame.Surface] = []
+        self.frames_flipX : list[pygame.Surface] = []
+        self.duration_list = []
+        self.duration_list_length = 0 # prevents calling len() each frame
+        self.numFrames : int = 0
+
+    def from_surface(self,surface:pygame.Surface,frame_size : Tuple[int,int])->Self:
+        """
+        Loads frames from a spritesheet containing all animation frames aligned horizontally, left to right
+        Frames are cut and stored in 2 versions, original and flipped on the horizontal axis.
+        Flipping sprites being pretty common, this serves as a builtin cache.
+        """
+        self.frames : List[pygame.Surface] = list(
+            bf.utils.split_surface(surface, frame_size).values()
+        )
+        self.frames_flipX : List[pygame.Surface] = list(
+            bf.utils.split_surface(
+                surface, frame_size,
+                func=lambda s : pygame.transform.flip(s,True,False)
+            ).values()
+        )
+        self.duration_list_length = len(self.frames)
+        self.numFrames = self.duration_list_length
+        if not self.duration_list:
+            self.duration_list = [1]*self.duration_list_length
+        return self
+
+    def __repr__(self):
+        return f"Animation({self.name})"
+
+    def counter_to_frame(self, counter: Union[float, int]) -> int:
+        if not self.frames : 
+            raise ValueError("Animation has no frames")
+        return search_index(
+            int(counter % self.duration_list_length), self.duration_list
+        )
+
+    def get_frame(self, counter: Union[float, int], flip: bool) -> pygame.Surface:
+        i = self.counter_to_frame(counter)
+        return self.frames_flipX[i] if flip else self.frames[i]
+
+    def set_duration_list(self, duration_list: Union[List[int], int]) -> Self:
+        if isinstance(duration_list, int):
+            duration_list = [duration_list] * len(self.frames)
+        if len(duration_list) != self.numFrames:
+            raise ValueError("duration_list should have values for all frames")
+        self.duration_list = duration_list
+        self.duration_list_length = sum(self.duration_list)
+        return self

{batframework-1.0.9a7 → batframework-1.0.9a9}/src/batFramework/audioManager.py

@@ -42,6 +42,9 @@ class AudioManager(metaclass=bf.Singleton):
         return name in self.sounds
 
     def load_sound(self, name, path, persistent=False) -> pygame.mixer.Sound:
+        """
+        if persistent==True the sound won't be unloaded when sounds are freed (unless force is used)
+        """
         if name in self.sounds:
             return self.sounds[name]["sound"]
         path = bf.ResourceManager().get_path(path)
@@ -52,8 +55,8 @@ class AudioManager(metaclass=bf.Singleton):
         }
         return self.sounds[name]["sound"]
 
-    def load_sounds(self, sound_data_list: list[tuple[str, str, bool]]) -> None:
-        for data in sound_data_list:
+    def load_sounds(self, sound_data: tuple[str, str, bool]) -> None:
+        for data in sound_data:
             self.load_sound(*data)
         return
 
@@ -83,8 +86,8 @@ class AudioManager(metaclass=bf.Singleton):
         self.musics[name] = bf.ResourceManager().get_path(path)
         return
 
-    def load_musics(self, music_data_list: list[tuple[str, str]]):
-        for data in music_data_list:
+    def load_musics(self, *music_data:tuple[str, str]):
+        for data in music_data:
             self.load_music(*data)
         return
 
@@ -101,8 +104,8 @@ class AudioManager(metaclass=bf.Singleton):
             self.current_music = name
             return True
         except KeyError:
+            print(f"Music '{name}' not loaded in AudioManager.")
             return False
-            # print(f"Music '{name}' not loaded in AudioManager.")
 
     def stop_music(self):
         if not self.current_music:

batframework-1.0.9a9/src/batFramework/baseScene.py

@@ -0,0 +1,240 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, Any
+if TYPE_CHECKING:
+    from .manager import Manager
+    from .sceneManager import SceneManager
+
+import pygame
+import itertools
+import batFramework as bf
+from .sceneLayer import SceneLayer
+
+class BaseScene:
+    def __init__(self,name: str) -> None:
+        """
+        Base Scene object.
+        Empty scene with no layers or gui setup
+        Args:
+            name: Name of the scene.
+        """
+        bf.TimeManager().add_register(name,False)
+        self.scene_index = 0
+        self.name = name
+        self.manager: Manager | None = None
+        self.active = False
+        self.visible = False
+        self.clear_color = bf.color.BLACK
+        self.actions: bf.ActionContainer = bf.ActionContainer()
+        self.early_actions: bf.ActionContainer = bf.ActionContainer()
+        self.scene_layers : list[SceneLayer] = []
+    
+    def set_clear_color(self,color):
+        """
+        Sets the clear color of the entire scene.
+        This color will fill the scene before all layers are drawn.
+        Results will not show if a layer has an opaque fill color on top.
+        Set to None to skip.
+        """
+        self.clear_color = color
+
+    def add_layer(self,layer:SceneLayer,index:int=0):
+        layer.set_scene(self)
+        self.scene_layers.insert(index,layer)
+
+    def remove_layer(self,index=0):
+        self.scene_layers.pop(index)
+
+    def set_layer(self,layername,layer):
+        for i,l in enumerate(self.scene_layers[::]):
+            if l.name == layername:
+                self.scene_layers[i] = layer
+                layer.set_scene(self)
+
+    def get_layer(self,name:str)->bf.SceneLayer:
+        for s in self.scene_layers:
+            if s.name == name:
+                return s
+        return None
+
+    def add(self,layer:str,*entities):
+        l = self.get_layer(layer)
+        if l is None : return 
+        l.add(*entities)
+
+    def remove(self,layer:str,*entities):
+        l = self.get_layer(layer)
+        if l is None : return
+        l.remove(*entities)
+
+    def __str__(self)->str:
+        return f"Scene({self.name})"
+
+    def set_scene_index(self, index: int):
+        """Set the scene index."""
+        self.scene_index = index
+
+    def get_scene_index(self) -> int:
+        """Get the scene index."""
+        return self.scene_index
+
+    def when_added(self):
+        for s in self.scene_layers:
+            s.flush_entity_changes()
+        self.do_when_added()
+
+    def do_when_added(self):
+        pass
+
+    def set_manager(self, manager_link: Manager):
+        """Set the manager link for the scene."""
+        self.manager = manager_link
+        self.manager.update_scene_states()
+
+    def set_visible(self, value: bool):
+        """Set the visibility of the scene."""
+        self.visible = value
+        if self.manager:
+            self.manager.update_scene_states()
+
+    def set_active(self, value):
+        """Set the activity of the scene."""
+        self.active = value
+        if self.manager:
+            self.manager.update_scene_states()
+
+    def is_active(self) -> bool:
+        """Check if the scene is active."""
+        return self.active
+
+    def is_visible(self) -> bool:
+        """Check if the scene is visible."""
+        return self.visible
+
+    def get_name(self) -> str:
+        """Get the name of the scene."""
+        return self.name
+
+    def get_by_tags(self, *tags):
+        """Get entities by their tags."""
+        return itertools.chain.from_iterable(l.get_by_tags(*tags) for l in self.scene_layers)
+
+    def get_by_uid(self, uid) -> bf.Entity | None:
+        """Get an entity by its unique identifier."""
+        for l in self.scene_layers:
+            r = l.get_by_uid(uid)
+            if r is not None:
+                return r
+        return None
+
+    def add_actions(self, *action):
+        """Add actions to the scene."""
+        self.actions.add_actions(*action)
+
+    def add_early_actions(self, *action):
+        """Add actions to the scene."""
+        self.early_actions.add_actions(*action)
+
+    def process_event(self, event: pygame.Event):
+        """
+        Propagates event while it is not consumed.
+        In order : do_early_handle_event
+        -> scene early_actions
+        -> propagate to all layers
+        -> do_handle_event
+        -> scene actions.
+        at each step, if the event is consumed the propagation stops
+        """
+        self.do_early_handle_event(event)
+        if event.consumed: return
+        self.early_actions.process_event(event)
+        if event.consumed: return
+
+        if self.manager.current_transition and event.type in bf.enums.playerInput:
+            return 
+        
+        for l in self.scene_layers:
+            l.process_event(event)
+            if event.consumed : return
+            
+        self.do_handle_event(event)
+
+        if event.consumed:return
+        self.actions.process_event(event)
+
+    # called before process event
+    def do_early_handle_event(self, event: pygame.Event):
+        """Called early in event propagation"""
+        pass
+
+    def do_handle_event(self, event: pygame.Event):
+        """called inside process_event but before resetting the scene's action container and propagating event to scene layers"""
+        pass
+
+    def update(self, dt):
+        """Update the scene. Do NOT override"""
+
+        #update all scene layers
+        for l in self.scene_layers:
+            l.update(dt)
+        self.do_update(dt)
+        self.actions.reset()
+        self.early_actions.reset()
+
+
+    def do_update(self, dt):
+        """Specific update within the scene."""
+        pass
+
+
+    def draw(self, surface: pygame.Surface):
+        if self.clear_color is not None:
+            surface.fill(self.clear_color)
+
+        self.do_early_draw(surface)
+
+        # Draw all layers back to front
+        for i,l in enumerate(reversed(self.scene_layers)):
+            #blit all layers onto surface
+            l.draw(surface)
+            if i < len(self.scene_layers)-1:
+                self.do_between_layer_draw(surface,l)
+        self.do_final_draw(surface)
+
+
+    def do_early_draw(self, surface: pygame.Surface):
+        """Called before any layer draw"""
+        pass
+
+    def do_between_layer_draw(self, surface: pygame.Surface,layer:SceneLayer):
+        """Called after drawing the argument layer (except the last layer)"""
+        pass
+
+    def do_final_draw(self, surface: pygame.Surface):
+        "Called after all layers"
+        pass
+
+    def on_enter(self):
+        self.set_active(True)
+        self.set_visible(True)
+        bf.TimeManager().activate_register(self.name)
+        self.do_on_enter()
+
+    def on_exit(self):
+        self.set_active(False)
+        self.set_visible(False)
+        self.actions.hard_reset()
+        self.early_actions.hard_reset()
+        bf.TimeManager().deactivate_register(self.name)
+        self.do_on_exit()
+
+    def do_on_enter(self) -> None:
+        pass
+
+    def do_on_exit(self) -> None:
+        pass
+
+    def do_on_enter_early(self) -> None:
+        pass
+
+    def do_on_exit_early(self) -> None:
+        pass

{batframework-1.0.9a7 → batframework-1.0.9a9}/src/batFramework/camera.py

@@ -41,6 +41,9 @@ class Camera:
         self.min_zoom = 0.1
         self.zoom(1)
 
+    def get_mouse_pos(self)->tuple[float,float]:
+        return self.screen_to_world(pygame.mouse.get_pos())
+
     def set_clear_color(self, color: pygame.Color | tuple | str) -> Self:
         """
         Set the clear color for the camera surface.
@@ -84,6 +87,7 @@ class Camera:
         """
         Clear the camera surface with the set clear color.
         """
+        if not self._clear_color: return
         self.surface.fill(self._clear_color)
 
     def get_center(self) -> tuple[float, float]:

{batframework-1.0.9a7 → batframework-1.0.9a9}/src/batFramework/constants.py

@@ -22,12 +22,17 @@ class Constants:
     def set_allow_debug(allow_debug:bool):
         Constants.ALLOW_DEBUG = allow_debug
 
-
     @staticmethod
     def set_resolution(resolution: tuple[int, int]):
         Constants.RESOLUTION = resolution
         Constants.WIDTH = resolution[0]
         Constants.HEIGHT = resolution[1]
+        Constants.update_screen()
+
+    @staticmethod
+    def update_screen():
+        if Constants.BF_INITIALIZED:
+            Constants.SCREEN = pygame.display.set_mode(Constants.RESOLUTION,Constants.FLAGS,vsync=Constants.VSYNC)
 
     @staticmethod
     def set_default_cursor(cursor: pygame.Cursor):
@@ -44,4 +49,3 @@ class Constants:
     @staticmethod
     def set_fps_limit(value: int):
         Constants.FPS = value
-        print("FPS limit to : ", value)