batframework 1.0.9a10__py3-none-any.whl → 1.0.10__py3-none-any.whl

batFramework/__init__.py

@@ -1,90 +1,67 @@
-import os
+__version__ = "1.0.10"
+initialized = False
+
 import pygame
-import json
-import batFramework as bf
 from .constants import Constants as const
+import os
+import json
+
+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 .timeManager import TimeManager,Timer,SceneTimer
-from .easingController import EasingController
-from .propertyEaser import PropertyEaser
-from .cutsceneManager import CutsceneManager
-import batFramework.cutscene as cutscene
+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 .drawable import Drawable
-from .renderGroup import RenderGroup
 from .dynamicEntity import DynamicEntity
-from .sprite import Sprite
-from .scrollingSprite import ScrollingSprite
-from .particle import *
-from .animation import Animation
-from .animatedSprite import AnimatedSprite
+from .animatedSprite import AnimatedSprite, AnimState
 from .stateMachine import State, StateMachine
-from .sceneLayer import SceneLayer
+from .particles import Particle, ParticleManager
 from .scene import Scene
-from .baseScene import BaseScene
-import batFramework.gui as gui
+from .gui import * 
 from .sceneManager import SceneManager
 from .manager import Manager
-from .templates import *
-
-
-def init_screen(resolution: tuple[int, int], flags: int = 0, vsync: int = 0):
-    const.set_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]}"
-    )
 
-
-def print_version():
-    # Dynamically construct the path to version.json
-    version_file = os.path.join(os.path.dirname(__file__), "version.json")
-    try:
-        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],
-    flags: int = 0,
-    window_caption: str = "BatFramework Project",
-    resource_path: str | None = None,
-    default_font_size=None,
-    default_font=None,
-    fps_limit: int = 0,
-    vsync: int = 0,
-):
-    print_version()
-    pygame.display.set_caption(window_caption)
-    init_screen(resolution, flags, vsync)
-    pygame.mixer.init()
-    
-    ResourceManager().set_resource_path(
-        resource_path if resource_path is not None else "."
-    )
-    if resource_path is not None:
-        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)
-    const.BF_INITIALIZED = True
-    const.set_fps_limit(fps_limit)

batFramework/action.py

@@ -1,8 +1,8 @@
-from typing import Any, Self
+from typing import Any
 from enum import Enum
 import pygame
-from .enums import actionType
 
+ActionType = Enum("type", "INSTANTANEOUS CONTINUOUS HOLDING")
 
 class Action:
     def __init__(self, name: str) -> None:
@@ -12,28 +12,34 @@ class Action:
         Args:
             name (str): The name of the action.
         """
-        self.name: str = name
-        self.active: bool = False
-        self.data: dict = {}
-        self.consume_event: bool = False
-        self._type: actionType = actionType.INSTANTANEOUS
-        self._key_control: set = set()
-        self._mouse_control: set = set()
-        self._event_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
 
-    def set_consume_event(self, val: bool) -> Self:
+    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.
         """
-        self.consume_event = val
-        return self
+        self._unique = val
+
+    def is_active(self) -> bool:
+        """
+        Check if the action is currently active.
+
+        Returns:
+            bool: True if the action is active, False otherwise.
+        """
+        return self._active
 
     def set_active(self, value: bool) -> None:
         """
@@ -42,18 +48,10 @@ class Action:
         Args:
             value (bool): True to activate the action, False to deactivate it.
         """
-        self.active = value
-        
-
-    def add_event_control(self, *events) -> Self:
-        self._event_control.update(events)
-        return self
-
-    def remove_event_control(self, *events) -> Self:
-        self._event_control = self._event_control - events
-        return self
+        self._active = value
+        self._holding = set()
 
-    def add_key_control(self, *keys) -> Self:
+    def add_key_control(self, *keys) -> 'Action':
         """
         Add key controls to the action.
 
@@ -66,51 +64,29 @@ class Action:
         self._key_control.update(keys)
         return self
 
-    def remove_key_control(self, *keys: int) -> Self:
+    def add_mouse_control(self, *mouse_buttons) -> 'Action':
         """
-        Remove key controls to the action.
+        Add mouse control to the action.
 
         Args:
-            *keys (int): Key codes to control this action.
+            *mouse_buttons (int): Mouse button codes to control this action.
 
         Returns:
             Action: The updated Action object for method chaining.
         """
-        self._key_control = self._key_control - set(keys)
+        self._mouse_control.update(mouse_buttons)
         return self
 
-    def replace_key_control(self, key, new_key) -> Self:
-        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: int) -> Self:
+    def get_name(self) -> str:
         """
-        Add mouse control to the action.
-
-        Args:
-            *mouse_buttons (int): Mouse button codes to control this action.
+        Get the name of the action.
 
         Returns:
-            Action: The updated Action object for method chaining.
+            str: The name of the action.
         """
-        self._mouse_control.update(mouse)
-        return self
-
-    def remove_mouse_control(self, *mouse: int) -> Self:
-        self._mouse_control = self._mouse_control - set(mouse)
-        return self
+        return self._name
 
-    def replace_mouse_control(self, mouse, new_mouse) -> Self:
-        if not mouse in self._mouse_control:
-            return self
-        self.remove_mouse_control(mouse)
-        self.add_mouse_control(new_mouse)
-        return self
-
-    def set_continuous(self) -> Self:
+    def set_continuous(self) -> 'Action':
         """
         Set the action type to continuous.
 
@@ -118,7 +94,7 @@ class Action:
             Action: The updated Action object for method chaining.
         """
         self._holding = set()
-        self._type = actionType.CONTINUOUS
+        self._type = ActionType.CONTINUOUS
         return self
 
     def is_continuous(self) -> bool:
@@ -128,16 +104,16 @@ class Action:
         Returns:
             bool: True if the action type is continuous, False otherwise.
         """
-        return self._type == actionType.CONTINUOUS
+        return self._type == ActionType.CONTINUOUS
 
-    def set_instantaneous(self) -> Self:
+    def set_instantaneous(self) -> 'Action':
         """
         Set the action type to instantaneous.
 
         Returns:
             Action: The updated Action object for method chaining.
         """
-        self._type = actionType.INSTANTANEOUS
+        self._type = ActionType.INSTANTANEOUS
         self._holding = set()
         return self
 
@@ -148,16 +124,16 @@ class Action:
         Returns:
             bool: True if the action type is instantaneous, False otherwise.
         """
-        return self._type == actionType.INSTANTANEOUS
+        return self._type == ActionType.INSTANTANEOUS
 
-    def set_holding(self) -> Self:
+    def set_holding(self) -> 'Action':
         """
         Set the action type to holding.
 
         Returns:
             Action: The updated Action object for method chaining.
         """
-        self._type = actionType.HOLDING
+        self._type = ActionType.HOLDING
         return self
 
     def is_holding_type(self) -> bool:
@@ -167,17 +143,13 @@ class Action:
         Returns:
             bool: True if the action type is holding, False otherwise.
         """
-        return self._type == actionType.HOLDING
+        return self._type == ActionType.HOLDING
 
-    def process_update(self, event: pygame.Event) -> None:
-        if (
-            event.type == pygame.MOUSEMOTION
-            and self._type == actionType.HOLDING
-            and pygame.MOUSEMOTION in self._mouse_control
-        ) or self._event_control:
-            self.data = event.dict
+    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):
+    def process_activate(self, event: pygame.event.Event) -> bool:
         """
         Process activation of the action based on a pygame event.
 
@@ -187,93 +159,94 @@ class Action:
         Returns:
             bool: True if the action was activated by the event, False otherwise.
         """
-
         if event.type == pygame.KEYDOWN and event.key in self._key_control:
-            self._activate_action(event.key)
+            self._active = True
+            if self.is_holding_type():
+                self._holding.add(event.key)
+            return True
 
-        elif (
-            event.type == pygame.MOUSEBUTTONDOWN and event.button in self._mouse_control
-        ):
-            self._activate_action(event.button)
+        if event.type == pygame.MOUSEBUTTONDOWN and event.button in self._mouse_control:
+            self._active = True
+            if self.is_holding_type():
+                self._holding.add(event.button)
+            return True
 
-        elif event.type == pygame.MOUSEMOTION and event.type in self._mouse_control:
-            self._activate_action(event.type)
+        if event.type == pygame.MOUSEMOTION and event.type in self._mouse_control:
+            self._active = True
+            if self.is_holding_type():
+                self._holding.add(event.type)
+            return True
 
-        elif event.type in self._event_control:
-            self._activate_action(event.type)
-            self.data = event.dict
-        else:
-            return
-        if self.consume_event:
-            event.consumed = True
+        return False
 
-    def _activate_action(self, control):
-        self.active = True
-        if self._type == actionType.HOLDING:
-            self._holding.add(control)
-
-    def process_deactivate(self, event: pygame.event.Event):
+    def process_deactivate(self, event: pygame.event.Event) -> bool:
         """
         Process deactivation of the action based on a pygame event.
 
         Args:
             event (pygame.event.Event): The pygame event to process.
 
+        Returns:
+            bool: True if the action was deactivated by the event, False otherwise.
         """
-        if self._type == actionType.HOLDING:
+        if self._type == ActionType.HOLDING:
             if event.type == pygame.KEYUP and event.key in self._key_control:
-                self._deactivate_action(event.key)
+                if event.key in self._holding:
+                    self._holding.remove(event.key)
+                if not self._holding:
+                    self._active = False
+                    return True
             elif (
                 event.type == pygame.MOUSEBUTTONUP
                 and event.button in self._mouse_control
             ):
-                self._deactivate_action(event.button)
-            elif event.type == pygame.MOUSEMOTION and event.type in self._mouse_control:
-                self._deactivate_action(event.type)
-            elif event.type in self._event_control:
-                self._deactivate_action(event.type)
-            else:
-                event.consumed = False
-
-        if self.consume_event:
-            event.consumed = True
+                if event.button in self._holding:
+                    self._holding.remove(event.button)
+                if not self._holding:
+                    self._active = False
+                    return True
+            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)
+                if not self._holding:
+                    self._active = False
+                    return True
 
-    def _deactivate_action(self, control) -> bool:
-        if control in self._holding:
-            self._holding.remove(control)
-        if not self._holding:
-            self.active = False
+        return False
 
-    def process_event(self, event: pygame.event.Event):
+    def process_event(self, event: pygame.event.Event) -> bool:
         """
         Process a pygame event and update the action's state.
 
         Args:
             event (pygame.event.Event): The pygame event to process.
-        """
 
-        if event.consumed:
-            return
-        if not self.active:
-            self.process_activate(event)
+        Returns:
+            bool: True if the action state changed, False otherwise.
+        """
+        if not self._active:
+            res = self.process_activate(event)
         else:
-            self.process_deactivate(event)
-        if self.active:
-            self.process_update(event)
-        return
+            res = self.process_deactivate(event)
+        self.process_update(event)
+        return res
 
     def reset(self) -> None:
         """
         Reset the action's state to the default state.
         """
-        if self._type in {actionType.CONTINUOUS, actionType.HOLDING}:
+        if self._type in {ActionType.CONTINUOUS, ActionType.HOLDING}:
             return
-        elif self._type == actionType.INSTANTANEOUS:
-            self.active = False
+        elif self._type == ActionType.INSTANTANEOUS:
+            self._active = False
 
     def hard_reset(self) -> None:
         """
         Hard reset the action, deactivating it and clearing any holding controls.
         """
-        self.active = False
+        self._active = False
         self._holding = set()

batFramework/actionContainer.py

@@ -1,44 +1,32 @@
 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_actions(*actions)
-
-    def __iter__(self):
-        return iter(self._actions.values())
+            self.add_action(*actions)
 
     def clear(self):
         self._actions = {}
 
-    def add_actions(self, *actions: bf.Action):
+    def add_action(self, *actions: bf.Action):
         for action in actions:
-            self._actions[action.name] = action
+            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).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):
-        if event.consumed:
-            return
         for action in self._actions.values():
-            action.process_event(event)
-            if event.consumed == True:
+            a = action.process_event(event)
+            if a and action._unique:
                 break
 
     def reset(self):
@@ -48,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(),
-        )