batframework 1.0.6__py3-none-any.whl → 1.0.8a1__py3-none-any.whl

batFramework/__init__.py

@@ -2,7 +2,6 @@ import pygame
 import batFramework as bf
 import sys
 from .constants import Constants as const
-from .constants import Colors as color
 from .utils import Singleton
 from .enums import *
 from .resourceManager import ResourceManager
@@ -10,36 +9,41 @@ from .fontManager import FontManager
 from .utils import Utils as utils
 from .tileset import Tileset
 from .time import TimeManager, Timer
+from .easingController import EasingController
 from .cutscene import Cutscene, CutsceneManager
 from .cutsceneBlocks import *
-from .easing import Easing, EasingAnimation
 from .audioManager import AudioManager
 import batFramework.transition as transition
 from .action import Action
 from .actionContainer import *
 from .camera import Camera
+from .object import Object
 from .entity import Entity
+from .renderGroup import RenderGroup
 from .dynamicEntity import DynamicEntity
 from .sprite import Sprite
+from .scrollingSprite import ScrollingSprite
+from .particle import *
 from .animatedSprite import AnimatedSprite, AnimState
 from .stateMachine import State, StateMachine
 from .scene import Scene
-from .gui import * 
+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
+        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,
@@ -48,13 +52,18 @@ def init(
     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 ".")
+    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)
+    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,9 @@
-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,18 +13,19 @@ 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: 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.
@@ -31,16 +33,8 @@ class Action:
         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:
         """
@@ -49,10 +43,20 @@ 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_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) -> "Action":
+    def add_key_control(self, *keys) -> Self:
         """
         Add key controls to the action.
 
@@ -65,7 +69,7 @@ class Action:
         self._key_control.update(keys)
         return self
 
-    def remove_key_control(self, *keys:int) -> "Action":
+    def remove_key_control(self, *keys: int) -> Self:
         """
         Remove key controls to the action.
 
@@ -78,13 +82,14 @@ class Action:
         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
+    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_buttons:int) -> "Action":
+    def add_mouse_control(self, *mouse_buttons: int) -> Self:
         """
         Add mouse control to the action.
 
@@ -97,16 +102,7 @@ class Action:
         self._mouse_control.update(mouse_buttons)
         return self
 
-    def get_name(self) -> str:
-        """
-        Get the name of the action.
-
-        Returns:
-            str: The name of the action.
-        """
-        return self._name
-
-    def set_continuous(self) -> "Action":
+    def set_continuous(self) -> Self:
         """
         Set the action type to continuous.
 
@@ -114,7 +110,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:
@@ -124,16 +120,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
 
@@ -144,16 +140,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:
@@ -163,18 +159,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()
+            event.type == pygame.MOUSEMOTION
+            and self._type == actionType.HOLDING
             and pygame.MOUSEMOTION in self._mouse_control
-        ):
-            self.data = {"pos": event.pos, "rel": event.rel}
+        ) 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.
 
@@ -184,91 +179,85 @@ 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)
+
+        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) -> bool:
+    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
-            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
+                self._deactivate_action(event.key)
+            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.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.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

@@ -6,14 +6,17 @@ 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:
         return self._actions.get(name)
@@ -26,16 +29,16 @@ class ActionContainer:
 
     def is_active(self, *names: str) -> bool:
         return all(
-            self._actions.get(name).is_active() if name in self._actions else False
+            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:
-                break
-
+            action.process_event(event)
+            if event.consumed == True:break
+             
     def reset(self):
         for action in self._actions.values():
             action.reset()

batFramework/animatedSprite.py

@@ -13,27 +13,34 @@ def search_index(target, lst):
 
 class AnimState:
     def __init__(
-        self, name: str, file, width, height, duration_list: list | int,convert_alpha:bool=True
+        self,
+        name: str,
+        surface: pygame.Surface,
+        width,
+        height,
+        duration_list: list | int,
     ) -> None:
-        self.frames: list[pygame.Surface] =bf.utils.img_slice(
-            file, width, height,
-            False,convert_alpha
+        self.frames: list[pygame.Surface] = list(
+            bf.utils.split_surface(
+                surface, width, height, False, convert_alpha
+            ).values()
         )
-        self.frames_flipX: list[pygame.Surface] = bf.utils.img_slice(
-            file, width, height,
-            True,convert_alpha
+        self.frames_flipX: list[pygame.Surface] = list(
+            bf.utils.split_surface(surface, width, height, True, convert_alpha).values()
         )
-        
+
         self.name = name
-        self.duration_list :list[int]= []
+        self.duration_list: list[int] = []
         self.duration_list_length = 0
         self.set_duration_list(duration_list)
 
     def __repr__(self):
         return f"AnimState({self.name})"
 
-    def counter_to_frame(self, counter: float | int)->int:
-        return search_index(int(counter % self.duration_list_length), self.duration_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(self, counter, flip):
         i = self.counter_to_frame(counter)
@@ -51,47 +58,49 @@ class AnimState:
 class AnimatedSprite(bf.DynamicEntity):
     def __init__(self, size=None) -> None:
         super().__init__(size, no_surface=True)
-        self.float_counter :float= 0
+        self.float_counter: float = 0
         self.animStates: dict[str, AnimState] = {}
-        self.current_state: AnimState|None = None  
+        self.current_state: AnimState | None = None
         self.flipX = False
         self._locked = False
-        self.paused : bool = False
+        self.paused: bool = False
 
-    def pause(self)->None:
+    def pause(self) -> None:
         self.paused = True
 
-    def resume(self)->None:
+    def resume(self) -> None:
         self.paused = False
 
-    def toggle_pause(self)->None:
+    def toggle_pause(self) -> None:
         self.paused = not self.paused
 
-    def set_counter(self, value: float)->None:
+    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
+    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))
+        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:
+            if self.current_state.counter_to_frame(new_counter) >= frame_index:
                 break
-            new_counter +=self.current_state.duration_list[i]
-            i+=1 
+            new_counter += self.current_state.duration_list[i]
+            i += 1
         self.set_counter(new_counter)
-    def lock(self)->None:
+
+    def lock(self) -> None:
         self._locked = True
 
-    def unlock(self)->None:
+    def unlock(self) -> None:
         self._locked = False
 
-    def set_flipX(self, value)->None:
+    def set_flipX(self, value) -> None:
         self.flipX = value
 
-    def remove_animState(self, name: str)->bool:
+    def remove_animState(self, name: str) -> bool:
         if not name in self.animStates:
             return False
         self.animStates.pop(name)
@@ -100,51 +109,59 @@ class AnimatedSprite(bf.DynamicEntity):
                 list(self.animStates.keys())[0] if self.animStates else ""
             )
         return True
-        
+
     def add_animState(
-        self, name: str, file: str, size: tuple[int, int], duration_list: list[int],
-        convert_alpha:bool=True
-    )->bool:
+        self,
+        name: str,
+        surface: pygame.Surface,
+        size: tuple[int, int],
+        duration_list: list[int],
+        convert_alpha: bool = True,
+    ) -> bool:
         if name in self.animStates:
             return False
-        self.animStates[name] = AnimState(name, file, *size, duration_list,convert_alpha)
+        self.animStates[name] = AnimState(name, surface, *size, duration_list)
         if len(self.animStates) == 1:
             self.set_animState(name)
         return True
-        
-    def set_animState(self, state: str, reset_counter=True, lock=False)->bool:
+
+    def set_animState(self, state: str, reset_counter=True, lock=False) -> bool:
         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))
-        
+        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.float_counter = 0
         if lock:
             self.lock()
         return True
 
-    def get_animState(self)->AnimState|None:
+    def get_animState(self) -> AnimState | None:
         return self.current_state
 
-    def update(self, dt: float)->None:
+    def update(self, dt: float) -> None:
         s = self.get_animState()
-        if not self.animStates or s is None :
+        if not self.animStates or s is None:
             return
-        if not self.paused : 
+        if not self.paused:
             self.float_counter += 60 * dt
             if self.float_counter > s.duration_list_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:
+        if (
+            not self.visible
+            or not camera.rect.colliderect(self.rect)
+            or not self.current_state
+        ):
             return 0
         camera.surface.blit(
             self.current_state.get_frame(self.float_counter, self.flipX),
-            camera.transpose(self.rect),
+            camera.world_to_screen(self.rect),
         )
         return 1