batframework 1.0.8a9__py3-none-any.whl → 1.0.8a11__py3-none-any.whl

batFramework/__init__.py

@@ -1,66 +1,83 @@
 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 .time import Time, Timer
-from .cutscene import Cutscene,CutsceneManager
+from .tileset import Tileset
+from .time import *
+from .easingController import EasingController
+from .cutscene import Cutscene, CutsceneManager
 from .cutsceneBlocks import *
-from .easing import Easing, EasingAnimation
 from .audioManager import AudioManager
-from .utils import Layout, Alignment, Direction
-from .transition import *
+import batFramework.transition as transition
 from .action import Action
-from .actionContainer import ActionContainer
+from .actionContainer import *
 from .camera import Camera
+from .object import Object
 from .entity import Entity
+from .renderGroup import RenderGroup
 from .dynamicEntity import DynamicEntity
-from .animatedSprite import AnimatedSprite, AnimState
+from .sprite import Sprite
+from .scrollingSprite import ScrollingSprite
+from .particle import *
+from .animatedSprite import AnimatedSprite, Animation
+from .character import Character
 from .stateMachine import State, StateMachine
-from .particles import Particle, ParticleManager
-# from .debugger import Debugger
 from .scene import Scene
-from .gui import * 
+from .gui import *
 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.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 print_version():
+    package_name = "batFramework"
+    try:
+        version = importlib.metadata.version(package_name)
+        print(f"{package_name} version: {version}")
+    except importlib.metadata.PackageNotFoundError:
+        print(f"{package_name} is not installed")
+
+
+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,
+):
+    print_version()
+    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

@@ -1,8 +1,8 @@
-from typing import Any
+from typing import Any, Self
 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,34 +12,28 @@ class Action:
         Args:
             name (str): The name of the action.
         """
-        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.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._holding = set()
-        self._unique = True
-        self.data : Any = None
 
-    def set_unique(self, val: bool) -> None:
+    def set_consume_event(self, val: bool) -> Self:
         """
         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._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
+        self.consume_event = val
+        return self
 
     def set_active(self, value: bool) -> None:
         """
@@ -48,10 +42,18 @@ class Action:
         Args:
             value (bool): True to activate the action, False to deactivate it.
         """
-        self._active = value
-        self._holding = set()
+        self.active = value
+        # self._holding = set()
 
-    def add_key_control(self, *keys) -> 'Action':
+    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
+
+    def add_key_control(self, *keys) -> Self:
         """
         Add key controls to the action.
 
@@ -64,29 +66,51 @@ class Action:
         self._key_control.update(keys)
         return self
 
-    def add_mouse_control(self, *mouse_buttons) -> 'Action':
+    def remove_key_control(self, *keys: int) -> Self:
         """
-        Add mouse control to the action.
+        Remove key controls to the action.
 
         Args:
-            *mouse_buttons (int): Mouse button codes to control this action.
+            *keys (int): Key codes to control this action.
 
         Returns:
             Action: The updated Action object for method chaining.
         """
-        self._mouse_control.update(mouse_buttons)
+        self._key_control = self._key_control - set(keys)
         return self
 
-    def get_name(self) -> str:
+    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:
         """
-        Get the name of the action.
+        Add mouse control to the action.
+
+        Args:
+            *mouse_buttons (int): Mouse button codes to control this action.
 
         Returns:
-            str: The name of the action.
+            Action: The updated Action object for method chaining.
         """
-        return self._name
+        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
 
-    def set_continuous(self) -> 'Action':
+    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:
         """
         Set the action type to continuous.
 
@@ -94,7 +118,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:
@@ -104,16 +128,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) -> 'Action':
+    def set_instantaneous(self) -> Self:
         """
         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
 
@@ -124,16 +148,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) -> 'Action':
+    def set_holding(self) -> Self:
         """
         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:
@@ -143,13 +167,17 @@ 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 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 (
+            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_activate(self, event: pygame.event.Event) -> bool:
+    def process_activate(self, event: pygame.event.Event):
         """
         Process activation of the action based on a pygame event.
 
@@ -159,94 +187,93 @@ 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._active = True
-            if self.is_holding_type():
-                self._holding.add(event.key)
-            return True
+            self._activate_action(event.key)
 
-        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.MOUSEBUTTONDOWN and event.button in self._mouse_control
+        ):
+            self._activate_action(event.button)
 
-        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 == pygame.MOUSEMOTION and event.type in self._mouse_control:
+            self._activate_action(event.type)
 
-        return False
+        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
 
-    def process_deactivate(self, event: pygame.event.Event) -> bool:
+    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):
         """
         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:
-                if event.key in self._holding:
-                    self._holding.remove(event.key)
-                if not self._holding:
-                    self._active = False
-                    return True
+                self._deactivate_action(event.key)
             elif (
                 event.type == pygame.MOUSEBUTTONUP
                 and event.button in self._mouse_control
             ):
-                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
+                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
 
-        return False
+    def _deactivate_action(self, control) -> bool:
+        if control in self._holding:
+            self._holding.remove(control)
+        if not self._holding:
+            self.active = False
 
-    def process_event(self, event: pygame.event.Event) -> bool:
+    def process_event(self, event: pygame.event.Event):
         """
         Process a pygame event and update the action's state.
 
         Args:
             event (pygame.event.Event): The pygame event to process.
-
-        Returns:
-            bool: True if the action state changed, False otherwise.
         """
-        if not self._active:
-            res = self.process_activate(event)
+
+        if event.consumed:
+            return
+        if not self.active:
+            self.process_activate(event)
         else:
-            res = self.process_deactivate(event)
-        self.process_update(event)
-        return res
+            self.process_deactivate(event)
+        if self.active:
+            self.process_update(event)
+        return
 
     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,32 +1,44 @@
 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_action(*actions)
+            self.add_actions(*actions)
+
+    def __iter__(self):
+        return iter(self._actions.values())
 
     def clear(self):
         self._actions = {}
 
-    def add_action(self, *actions: bf.Action):
+    def add_actions(self, *actions: bf.Action):
         for action in actions:
-            self._actions[action.get_name()] = action
+            self._actions[action.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 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 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 process_event(self, event):
+        if event.consumed:
+            return
         for action in self._actions.values():
-            a = action.process_event(event)
-            if a and action._unique:
+            action.process_event(event)
+            if event.consumed == True:
                 break
 
     def reset(self):
@@ -36,3 +48,35 @@ 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(),
+        )