batframework 1.0.7__py3-none-any.whl → 1.0.8a2__py3-none-any.whl

batFramework/__init__.py

@@ -1,60 +1,66 @@
 import pygame
-import batFramework as bf
-import sys
 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 .enums import *
-from .resourceManager import ResourceManager
-from .fontManager import FontManager
 from .utils import Utils as utils
-from .tileset import Tileset
-from .time import TimeManager, Timer
-from .cutscene import Cutscene, CutsceneManager
+from .time import Time, Timer
+from .cutscene import Cutscene,CutsceneManager
 from .cutsceneBlocks import *
 from .easing import Easing, EasingAnimation
 from .audioManager import AudioManager
-import batFramework.transition as transition
+from .utils import Layout, Alignment, Direction
+from .transition import *
 from .action import Action
-from .actionContainer import *
+from .actionContainer import ActionContainer
 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 .particles import Particle, ParticleManager
+# 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 ".")
-        if resource_path is not None : 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/action.py

@@ -12,21 +12,20 @@ class Action:
         Args:
             name (str): The name of the action.
         """
-        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._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
+        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.
@@ -52,7 +51,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.
 
@@ -65,26 +64,7 @@ class Action:
         self._key_control.update(keys)
         return self
 
-    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":
+    def add_mouse_control(self, *mouse_buttons) -> 'Action':
         """
         Add mouse control to the action.
 
@@ -106,7 +86,7 @@ class Action:
         """
         return self._name
 
-    def set_continuous(self) -> "Action":
+    def set_continuous(self) -> 'Action':
         """
         Set the action type to continuous.
 
@@ -126,7 +106,7 @@ class Action:
         """
         return self._type == ActionType.CONTINUOUS
 
-    def set_instantaneous(self) -> "Action":
+    def set_instantaneous(self) -> 'Action':
         """
         Set the action type to instantaneous.
 
@@ -146,7 +126,7 @@ class Action:
         """
         return self._type == ActionType.INSTANTANEOUS
 
-    def set_holding(self) -> "Action":
+    def set_holding(self) -> 'Action':
         """
         Set the action type to holding.
 
@@ -165,14 +145,9 @@ 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:
         """
@@ -230,7 +205,10 @@ 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/actionContainer.py

@@ -1,5 +1,4 @@
 import batFramework as bf
-import pygame
 
 
 class ActionContainer:
@@ -15,20 +14,14 @@ class ActionContainer:
         for action in actions:
             self._actions[action.get_name()] = action
 
-    def get(self, name: str) -> bf.Action:
+    def get(self,name:str)->bf.Action:
         return self._actions.get(name)
 
-    def has_action(self, name: str):
+    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 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():
@@ -43,35 +36,3 @@ class ActionContainer:
     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/animatedSprite.py

@@ -2,6 +2,7 @@ import batFramework as bf
 import pygame
 
 
+
 def search_index(target, lst):
     cumulative_sum = 0
     for index, value in enumerate(lst):
@@ -12,139 +13,105 @@ def search_index(target, lst):
 
 
 class AnimState:
-    def __init__(
-        self, name: str, file, width, height, duration_list: list | int,convert_alpha:bool=True
-    ) -> None:
-        self.frames: list[pygame.Surface] =bf.utils.img_slice(
-            file, width, height,
-            False,convert_alpha
-        )
+    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,convert_alpha
+            file, width, height, True
         )
-        
-        self.name = name
-        self.duration_list :list[int]= []
-        self.duration_list_length = 0
-        self.set_duration_list(duration_list)
 
-    def __repr__(self):
-        return f"AnimState({self.name})"
+        self.frame_length_list = []
+        self.ffl_length = 0
+        self.set_frame_length_list(frame_length_list)
 
-    def counter_to_frame(self, counter: float | int)->int:
-        return search_index(int(counter % self.duration_list_length), self.duration_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.counter_to_frame(counter)
+        i = self.get_frame_index(counter)
         return self.frames_flipX[i] if flip else self.frames[i]
 
-    def set_duration_list(self, duration_list: list[int] | int):
-        if isinstance(duration_list, int):
-            duration_list = [duration_list] * len(self.frames)
-        if len(duration_list) != len(self.frames):
-            raise ValueError("duration_list should have values for all frames")
-        self.duration_list = duration_list
-        self.duration_list_length = sum(self.duration_list)
-
+    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 :float= 0
+        self.float_counter = 0
         self.animStates: dict[str, AnimState] = {}
-        self.current_state: AnimState|None = None  
+        self.current_animState :str = ""
         self.flipX = False
         self._locked = False
-        self.paused : bool = False
-
-    def pause(self)->None:
-        self.paused = True
-
-    def resume(self)->None:
-        self.paused = False
 
-    def toggle_pause(self)->None:
-        self.paused = not self.paused
-
-    def set_counter(self, value: float)->None:
+    def set_counter(self,value:float):
         self.float_counter = value
+        
 
-    def set_frame(self,frame_index:int)->None:
-        if not self.current_state : return
-        total = sum(self.current_state.duration_list)
-        frame_index = max(0,min(total,frame_index))
-        new_counter = 0
-        i = 0
-        while frame_index < total:
-            if self.current_state.counter_to_frame(new_counter)>=frame_index:
-                break
-            new_counter +=self.current_state.duration_list[i]
-            i+=1 
-        self.set_counter(new_counter)
-    def lock(self)->None:
+    def lock_animState(self):
         self._locked = True
 
-    def unlock(self)->None:
+    def unlock_animState(self):
         self._locked = False
 
-    def set_flipX(self, value)->None:
+    def set_flipX(self, value):
         self.flipX = value
 
-    def remove_animState(self, name: str)->bool:
-        if not name in self.animStates:
-            return False
-        self.animStates.pop(name)
-        if self.current_state and self.current_state.name == name:
-            self.current_animState = (
-                list(self.animStates.keys())[0] if self.animStates else ""
-            )
-        return True
-        
+    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], duration_list: list[int],
-        convert_alpha:bool=True
-    )->bool:
+        self, name: str, file: str, size: tuple[int, int], frame_length_list: list[int]
+    ):
         if name in self.animStates:
-            return False
-        self.animStates[name] = AnimState(name, file, *size, duration_list,convert_alpha)
-        if len(self.animStates) == 1:
-            self.set_animState(name)
-        return True
-        
-    def set_animState(self, state: str, reset_counter=True, lock=False)->bool:
+            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
-
-        animState = self.animStates[state]
-        self.current_state = animState
-
-        self.rect = (self.current_state.frames[0].get_frect(center=self.rect.center))
-        
-        if reset_counter or self.float_counter > sum(animState.duration_list):
+        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()
+            self.lock_animState()
         return True
 
-    def get_animState(self)->AnimState|None:
-        return self.current_state
+    def get_state(self):
+        return self.animStates.get(self.current_animState,None)
 
-    def update(self, dt: float)->None:
-        s = self.get_animState()
-        if not self.animStates or s is None :
-            return
-        if not self.paused : 
-            self.float_counter += 60 * dt
-            if self.float_counter > s.duration_list_length:
-                self.float_counter = 0
+    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) -> int:
-        if not self.visible or not camera.intersects(self.rect) or not self.current_state:
-            return 0
+    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.current_state.get_frame(self.float_counter, self.flipX),
+            self.get_state().get_frame(self.float_counter, self.flipX),
             camera.transpose(self.rect),
         )
-        return 1
+        return True

batFramework/audioManager.py

@@ -5,19 +5,24 @@ pygame.mixer.init()
 
 
 class AudioManager(metaclass=bf.Singleton):
-    def __init__(self)->None:
-        self.sounds: dict = {}
-        self.musics: dict = {}
-        self.current_music :str|None= None
-        self.music_volume :float= 1
-        self.sound_volume :float= 1
+    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:bool=False):
+    def free_sounds(self, force=False):
         if force:
             self.sounds = {}
             return
-        self.sounds =  {key:value for key,value in self.sounds.items() if value["persistent"]}
+        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
@@ -26,54 +31,38 @@ class AudioManager(metaclass=bf.Singleton):
         self.music_volume = volume
         pygame.mixer_music.set_volume(volume)
 
-    def has_sound(self, name:str):
+    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.ResourceManager().get_path(path)
+        path = bf.utils.get_path(path)
         self.sounds[name] = {
             "path": path,
             "sound": pygame.mixer.Sound(path),
-            "persistent": persistent
+            "persistent": persistent,
         }
         return self.sounds[name]["sound"]
 
-    def load_sounds(self,sound_data_list:list[tuple[str,str,bool]])->None:
-        for data in sound_data_list:
-            self.load_sound(*data)
-        return 
-        
     def play_sound(self, name, volume=1):
-        try:
-            self.sounds[name]["sound"].set_volume(volume * self.sound_volume)
-            self.sounds[name]["sound"].play()
-        except KeyError:
-            print(f"Sound '{name}' not loaded in AudioManager.")
+        self.sounds[name]["sound"].set_volume(volume * self.sound_volume)
+        self.sounds[name]["sound"].play()
 
     def stop_sound(self, name):
-        try:
+        if name in self.sounds:
             self.sounds[name]["sound"].stop()
-        except KeyError:
-            
-            print(f"Sound '{name}' not loaded in AudioManager.")
+
     def load_music(self, name, path):
-        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:
-            self.load_music(*data)
-        return
-        
+        self.musics[name] = bf.utils.get_path(path)
+
     def play_music(self, name, loop=0, fade=500):
-        try:
+        if name in self.musics:
             pygame.mixer_music.load(self.musics[name])
             pygame.mixer_music.play(loop, fade_ms=fade)
             self.current_music = name
-        except KeyError:
-            print(f"Music '{name}' not loaded in AudioManager.")
+        else:
+            print(f"Music '{name}' not found in AudioManager.")
 
     def stop_music(self):
         if not self.current_music:
@@ -94,6 +83,3 @@ class AudioManager(metaclass=bf.Singleton):
         if not self.current_music:
             return
         pygame.mixer_music.unpause()
-
-    def get_current_music(self)->str|None:
-        return self.current_music