batframework 1.0.10__py3-none-any.whl → 2.0.0__py3-none-any.whl

batFramework/audioManager.py

@@ -1,85 +1,156 @@
-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()
+import pygame
+import batFramework as bf
+
+class AudioManager(metaclass=bf.Singleton):
+    def __init__(self) -> None:
+        self._sounds: dict[str, dict] = {}
+        self._musics: dict[str, str] = {}
+        self._current_music: str | None = None
+        self._music_volume: float = 1.0
+        self._sound_volume: float = 1.0
+
+        self._channels: dict[str, pygame.mixer.Channel] = {}
+        self._channel_volumes: dict[str, float] = {}
+        self._use_custom_channels: bool = False
+
+        pygame.mixer.music.set_endevent(bf.const.MUSIC_END_EVENT)
+
+    # --- Channel management ---
+    def setup_channels(self, channels: dict[str, int]) -> None:
+        """
+        Setup channels by providing a dict of {channel_name: channel_index}.
+        Enables custom channel management.
+        """
+        pygame.mixer.set_num_channels(max(channels.values()) + 1)
+        self._channels = {
+            name: pygame.mixer.Channel(idx) for name, idx in channels.items()
+        }
+        self._channel_volumes = {name: 1.0 for name in channels.keys()}
+        self._use_custom_channels = True
+
+    def set_channel_volume(self, channel_name: str, volume: float) -> None:
+        if channel_name in self._channels:
+            clamped = max(0.0, min(volume, 1.0))
+            self._channel_volumes[channel_name] = clamped
+            self._channels[channel_name].set_volume(clamped)
+
+    def get_channel_volume(self, channel_name: str) -> float:
+        return self._channel_volumes.get(channel_name, 1.0)
+
+    # --- Sound management ---
+    def load_sound(self, name: str, path: str, persistent: bool = False) -> pygame.mixer.Sound:
+        if name in self._sounds:
+            return self._sounds[name]["sound"]
+        path = bf.ResourceManager().get_path(path)
+        sound = pygame.mixer.Sound(path)
+        self._sounds[name] = {
+            "sound": sound,
+            "path": path,
+            "persistent": persistent,
+        }
+        return sound
+
+    def load_sounds(self, sounds_data: list[tuple[str, str, bool]]) -> None:
+        for name, path, persistent in sounds_data:
+            self.load_sound(name, path, persistent)
+
+    def play_sound(self, name: str, volume: float = 1.0, channel_name: str | None = None) -> bool:
+        sound_data = self._sounds.get(name)
+        if not sound_data:
+            print(f"[AudioManager] Sound '{name}' not loaded.")
+            return False
+        sound = sound_data["sound"]
+        volume = max(0.0, min(volume, 1.0)) * self._sound_volume
+
+        if self._use_custom_channels and channel_name:
+            channel = self._channels.get(channel_name)
+            if not channel:
+                print(f"[AudioManager] Channel '{channel_name}' not found. Using default channel.")
+                sound.set_volume(volume)
+                sound.play()
+                return True
+            channel.set_volume(volume * self._channel_volumes.get(channel_name, 1.0))
+            channel.play(sound)
+        else:
+            # Default pygame behavior: auto assign a free channel
+            sound.set_volume(volume)
+            sound.play()
+        return True
+
+    def stop_sound(self, name: str) -> bool:
+        sound_data = self._sounds.get(name)
+        if not sound_data:
+            print(f"[AudioManager] Sound '{name}' not loaded.")
+            return False
+        sound_data["sound"].stop()
+        return True
+
+    def free_sounds(self, force: bool = False) -> None:
+        if force:
+            self._sounds.clear()
+        else:
+            self._sounds = {
+                name: data for name, data in self._sounds.items() if data["persistent"]
+            }
+
+    def set_sound_volume(self, volume: float) -> None:
+        self._sound_volume = max(0.0, min(volume, 1.0))
+
+    def get_sound_volume(self) -> float:
+        return self._sound_volume
+
+    # --- Music management ---
+    def load_music(self, name: str, path: str) -> None:
+        self._musics[name] = bf.ResourceManager().get_path(path)
+
+    def load_musics(self, musics_data: list[tuple[str, str]]) -> None:
+        for name, path in musics_data:
+            self.load_music(name, path)
+
+    def play_music(self, name: str, loops: int = 0, fade_ms: int = 500) -> bool:
+        path = self._musics.get(name)
+        if not path:
+            print(f"[AudioManager] Music '{name}' not loaded.")
+            return False
+        try:
+            pygame.mixer.music.load(path)
+            pygame.mixer.music.set_volume(self._music_volume)
+            pygame.mixer.music.play(loops=loops, fade_ms=fade_ms)
+            self._current_music = name
+            return True
+        except pygame.error as e:
+            print(f"[AudioManager] Failed to play music '{name}': {e}")
+            return False
+
+    def stop_music(self) -> None:
+        if self._current_music:
+            pygame.mixer.music.stop()
+            self._current_music = None
+
+    def fadeout_music(self, fade_ms: int) -> None:
+        if self._current_music:
+            pygame.mixer.music.fadeout(fade_ms)
+            self._current_music = None
+
+    def pause_music(self) -> None:
+        if self._current_music:
+            pygame.mixer.music.pause()
+
+    def resume_music(self) -> None:
+        if self._current_music:
+            pygame.mixer.music.unpause()
+
+    def free_music(self) -> None:
+        if self._current_music:
+            pygame.mixer.music.unload()
+            self._current_music = None
+
+    def set_music_volume(self, volume: float) -> None:
+        self._music_volume = max(0.0, min(volume, 1.0))
+        pygame.mixer.music.set_volume(self._music_volume)
+
+    def get_music_volume(self) -> float:
+        return self._music_volume
+
+    def get_current_music(self) -> str | None:
+        return self._current_music

batFramework/baseScene.py

@@ -0,0 +1,249 @@
+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 get_clear_color(self)->pygame.typing.ColorLike:
+        return self.clear_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:SceneLayer):
+        for i,l in enumerate(self.scene_layers[::]):
+            if l.name == layername:
+                self.scene_layers[i] = layer
+                layer.set_scene(self)
+
+    def set_layer_index(self,layername:str,index:int=-1):
+        index = min(index,len(self.scene_layers)-1)
+        layer = self.get_layer(layername)
+        if layer is None : return
+        self.scene_layers.remove(layer)
+        self.scene_layers.insert(index,layer)
+
+    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
+        -> 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.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 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