batframework 1.0.9a7__py3-none-any.whl → 1.0.9a9__py3-none-any.whl

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/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/animatedSprite.py

@@ -1,128 +1,59 @@
 import batFramework as bf
 import pygame
-from typing import List, Dict, Tuple, Union, Optional, Self
+from typing import List, Dict, Tuple, Union, Optional, Self, Callable, Any
 from .animation import Animation
 
 class AnimatedSprite(bf.Drawable):
-    def __init__(self, size: Optional[Tuple[int, int]] = None,*args,**kwargs) -> None:
-        super().__init__(size, no_surface=True,*args,**kwargs)
-        self.float_counter: float = 0
-        self.animations: Dict[str, Animation] = {}
-        self.current_state: Optional[Animation] = None
-        self.flipX: bool = False
-        self._locked: bool = False
-        self._paused: bool = False
-        self.animation_end_callback = None
-        self.transition_end_animation = None
-
-    def set_animation_end_callback(self,callback)->Self:
-        self.animation_end_callback = callback
-        return self
+    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 paused(self) -> bool:
-        return self._paused
-
-    @paused.setter
-    def paused(self, value: bool) -> None:
-        self._paused = value
-
-    def toggle_pause(self) -> None:
-        self.paused = not self.paused
-
-    def set_counter(self, value: float) -> None:
-        self.float_counter = value
-
-    def set_frame(self, frame_index: int) -> None:
-        if not self.current_state:
-            return
-        self.set_counter(sum(self.current_state.duration_list[:frame_index]))
-
-    def lock(self) -> None:
-        self._locked = True
-
-    def unlock(self) -> None:
-        self._locked = False
-
-    def set_flipX(self, value: bool) -> None:
-        self.flipX = value
-
-    def remove_animation(self, name: str) -> bool:
-        if name not in self.animations:
-            return False
-        self.animations.pop(name)
-        if self.current_state and self.current_state.name == name:
-            self.current_state = (
-                list(self.animations.values())[0] if self.animations else None
-            )
-        return True
-
-    def add_animation(
-        self,
-        animation:Animation
-    ) -> bool:
-        if animation.name in self.animations:
-            return False
-        self.animations[animation.name] = animation
-        return True
-
-    def set_animation(
-        self, state: str, reset_counter: bool = True, lock: bool = False
-    ) -> bool:
-        if state not in self.animations or self._locked:
-            return False
-        
-        animation = self.animations[state]
-        self.current_state = animation
-
-        if self.current_state.frames:
-            self.rect = self.current_state.frames[0].get_frect(center=self.rect.center)
+    def flipX(self)->bool:
+        return self._flipX
+    
+    @flipX.setter
+    def flipX(self,value:bool):
+        self._flipX = value
 
-        if reset_counter or (self.float_counter > animation.duration_list_length):
-            self.float_counter = 0
+    def set_end_callback(self,callback : Callable[[],Any]):
+        self.end_callback = callback 
 
-        if lock:
-            self.lock()
-        
-        if self.transition_end_animation is not None:
-            self.transition_end_animation = None
-        return True
-    
-    def transition_to_animation(self,transition:str,animation:str)->Self:
-        self.set_animation(transition)
-        self.transition_end_animation = animation
+    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 get_current_animation(self) -> Optional[Animation]:
-        return self.current_state
-
-    def update(self, dt: float) -> None:
-        s = self.get_current_animation()
-        if  self.animations and s is not None:
-            if not self.paused:
-                self.float_counter += 60 * dt
-                if self.float_counter > s.duration_list_length:
-                    if self.transition_end_animation is not None:
-                        # print(f"{self.transition_end_animation=}, {self.get_current_animation()=}")
-                        self.set_animation(self.transition_end_animation)
-                    if self.animation_end_callback is not None:
-                        self.animation_end_callback()
-                    self.float_counter = 0
-        super().update(dt)
-
-
-    def get_current_frame(self)->pygame.Surface:
-        return self.current_state.get_frame(self.float_counter, self.flipX)
-
-    def draw(self, camera: bf.Camera) -> None:
-        if (
-            not self.visible
-            or not camera.rect.colliderect(self.rect)
-            or not self.current_state
-        ):
+    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
-        camera.surface.blit(
-            self.get_current_frame(),
-            camera.world_to_screen(self.rect),
-        )
-        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/animation.py

@@ -17,15 +17,40 @@ class Animation:
         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 = 1
+        self.duration_list_length = 0 # prevents calling len() each frame
+        self.numFrames : int = 0
 
-    def from_surface(self,surface:pygame.Surface,size : Tuple[int,int])->Self:
-        self.frames         : List[pygame.Surface] = list(bf.utils.split_surface(surface, size).values())
-        self.frames_flipX   : List[pygame.Surface] = list(bf.utils.split_surface(surface, size,func=lambda s : pygame.transform.flip(s,True,False)).values())
+    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):
@@ -45,7 +70,7 @@ class Animation:
     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) != 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)

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/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/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/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)