batframework 1.0.9a11__py3-none-any.whl → 1.1.0__py3-none-any.whl

batFramework/baseScene.py

@@ -1,240 +0,0 @@
-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 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):
-        for i,l in enumerate(self.scene_layers[::]):
-            if l.name == layername:
-                self.scene_layers[i] = layer
-                layer.set_scene(self)
-
-    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
-        -> do_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.do_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 do_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

batFramework/cutsceneManager.py

@@ -1,34 +0,0 @@
-import batFramework as bf
-from typing import TYPE_CHECKING,Self
-import pygame
-# if TYPE_CHECKING:
-from .cutscene import Cutscene
-
-
-class CutsceneManager(metaclass=bf.Singleton):
-    def __init__(self) -> None:
-        self.current_cutscene: Cutscene = None
-        self.manager: bf.Manager = None
-        self.is_playing : bool = False
-    def set_manager(self, manager):
-        self.manager = manager
-
-    def process_event(self, event):
-        if self.current_cutscene is not None:
-            self.current_cutscene.process_event(event)
-            if event.type in bf.enums.playerInput:
-                event.consumed = True
-
-    def play(self,cutscene:Cutscene):
-        if self.current_cutscene is not None:return
-        
-        self.current_cutscene = cutscene
-        cutscene.start()
-        self.is_playing = True
-        
-    def update(self,dt):
-        if self.current_cutscene:
-            self.current_cutscene.update(dt)
-            if self.current_cutscene.is_over:
-                self.current_cutscene = None
-                self.is_playing = False

batFramework/drawable.py

@@ -1,77 +0,0 @@
-from typing import Any, Self
-import pygame
-import batFramework as bf
-from .entity import Entity
-
-
-class Drawable(Entity):
-    """
-    Basic entity class
-    """
-
-    def __init__(
-        self,
-        size: None | tuple[int|float] = None,
-        surface_flags: int = 0,
-        convert_alpha: bool = False,
-        *args,
-        **kwargs,
-    ) -> None:
-        super().__init__()
-        self.visible: bool = True
-        self.render_order: int = 0
-        if size is not None:
-            self.rect.size = size
-        self.convert_alpha: bool = convert_alpha
-        self.surface_flags: int = surface_flags
-        self.blit_flags: int = 0
-        self.drawn_by_group : bool = False # flag for render group  
-        self.surface: pygame.Surface = pygame.Surface(self.rect.size, surface_flags)
-        if convert_alpha:
-            self.surface = self.surface.convert_alpha()
-            self.surface.fill((0, 0, 0, 0))
-
-    def set_alpha(self, alpha: int) -> Self:
-        self.surface.set_alpha(min(max(0, alpha), 255))
-        return self
-
-    def get_alpha(self) -> int:
-        return self.surface.get_alpha()
-
-    def set_surface_flags(self, surface_flags: int) -> Self:
-        self.surface_flags = surface_flags
-        return self
-
-    def set_convert_alpha(self, value: bool) -> Self:
-        self.convert_alpha = value
-        return self
-
-    def set_blit_flags(self, blit_flags: int) -> Self:
-        self.blit_flags = blit_flags
-        return self
-
-    def get_debug_outlines(self):
-        if self.visible:
-            yield (self.rect, self.debug_color)
-
-    def set_render_order(self, render_order: int) -> Self:
-        self.render_order = render_order
-        if self.parent_layer:
-            self.parent_layer.update_draw_order()
-        return self
-
-    def set_visible(self, value: bool) -> Self:
-        self.visible = value
-        return self
-
-    def draw(self, camera: bf.Camera) -> None:
-        """
-        Draw the entity onto the camera surface
-        """
-        if not self.visible or self.drawn_by_group or not camera.rect.colliderect(self.rect) or self.surface.get_alpha() == 0:
-            return
-        camera.surface.blit(
-            self.surface,
-            camera.world_to_screen(self.rect),
-            special_flags=self.blit_flags,
-        )

batFramework/easingController.py

@@ -1,58 +0,0 @@
-import pygame
-import batFramework as bf
-from functools import lru_cache
-from typing import Callable,Any
-
-
-@lru_cache(maxsize=None)
-def process_value(progress: float, p0: float, p1: float, p2: float, p3: float) -> float:
-    if p0 == 0 and p1 == 0 and p2 == 1 and p3 == 1:  # Linear easing control points
-        return progress
-    t = progress
-    t_inv = 1.0 - t
-    t2 = t * t
-    t3 = t * t2
-    t_inv2 = t_inv * t_inv
-    return 3 * t_inv2 * t * p1 + 3 * t_inv * t2 * p3 + t3
-
-
-class EasingController(bf.Timer):
-    def __init__(
-        self,
-        duration: float = 1,
-        easing: bf.easing = bf.easing.LINEAR,
-        update_callback=None,
-        end_callback: Callable[[], Any] = None,
-        loop: int = 0,
-        register:str="global"
-    ) -> None:
-        self.easing_function = easing
-        self.update_callback: Callable[[float], Any] = update_callback
-        self.value: float = 0.0
-        super().__init__(duration, end_callback, loop, register)
-
-    def get_value(self) -> float:
-        return self.value
-
-    def start(self, force: bool = False):
-        super().start(force)
-        self.value = 0
-
-    def update(self, dt: float) -> None:
-        if self.get_progression() == 1:
-            return
-        super().update(dt)
-        if self.get_progression() == 0:
-            return
-        if self.easing_function == bf.easing.LINEAR: # avoid calculating if linear (just use progression as is)
-            self.value = self.get_progression()
-        else:
-            self.value = process_value(self.get_progression(), *self.easing_function.control_points)
-        
-        if self.update_callback:
-            self.update_callback(self.value)
-
-    def end(self):
-        if self.update_callback:
-            self.update_callback(1)
-        super().end()

batFramework/enums.py

@@ -1,135 +0,0 @@
-from enum import Enum
-import pygame
-
-playerInput = [pygame.KEYDOWN,pygame.MOUSEBUTTONDOWN,pygame.KEYUP,pygame.MOUSEBUTTONUP]
-
-class color:
-    WHITE = pygame.Color(255, 255, 255)
-    LIGHTER_GRAY = pygame.Color(236, 240, 241)
-    LIGHT_GRAY = pygame.Color(189, 195, 199)
-    DARK_GRAY = pygame.Color(66, 66, 66)
-    DARKER_GRAY = pygame.Color(23, 23, 23)
-    BLACK = pygame.Color(0, 0, 0)
-
-    TURQUOISE = pygame.Color(26, 188, 156)
-    TURQUOISE_SHADE = pygame.Color(22, 160, 133)
-
-    GREEN = pygame.Color(46, 204, 113)
-    GREEN_SHADE = pygame.Color(39, 174, 96)
-
-    BLUE = pygame.Color(52, 152, 219)
-    BLUE_SHADE = pygame.Color(41, 128, 185)
-
-    PURPLE = pygame.Color(155, 89, 182)
-    PURPLE_SHADE = pygame.Color(142, 68, 173)
-
-    CHARCOAL = pygame.Color(52, 73, 94)
-    CHARCOAL_SHADE = pygame.Color(44, 62, 80)
-
-    GOLD = pygame.Color(241, 196, 15)
-    GOLD_SHADE = pygame.Color(243, 156, 18)
-
-    ORANGE = pygame.Color(230, 126, 34)
-    ORANGE_SHADE = pygame.Color(211, 84, 0)
-
-    RED = pygame.Color(231, 76, 60)
-    RED_SHADE = pygame.Color(192, 57, 43)
-
-    CLOUD = pygame.Color(236, 240, 241)
-    CLOUD_SHADE = pygame.Color(189, 195, 199)
-
-    CONCRETE = pygame.Color(149, 165, 166)
-    CONCRETE_SHADE = pygame.Color(127, 140, 141)
-
-    # GB
-    DARKER_GB = pygame.Color(27, 42, 9)
-    DARK_GB = pygame.Color(14, 69, 11)
-    LIGHT_GB = pygame.Color(73, 107, 34)
-    LIGHTER_GB = pygame.Color(154, 158, 63)
-
-    @staticmethod
-    def mult(color: pygame.Color, factor: float):
-        return pygame.Color(
-            min(max(0, int(color.r * factor)), 255),
-            min(max(0, int(color.g * factor)), 255),
-            min(max(0, int(color.b * factor)), 255),
-            color.a
-        )
-
-class easing(Enum):
-    LINEAR = (0, 0, 1, 1)
-    EASE_IN = (0.95, 0, 1, 0.55)
-    EASE_OUT = (0.5, 1, 0.5, 1)
-    EASE_IN_OUT = (0.55, 0, 0.45, 1)
-    EASE_IN_OUT_ELASTIC = (0.76,-0.36,0.41,1.34)
-
-    def __init__(self, *control_points):
-        self.control_points = control_points
-
-    @classmethod
-    def create(cls, *control_points):
-        """Create a custom easing instance."""
-        instance = object.__new__(cls)  
-        instance._value_ = control_points
-        instance.control_points = control_points
-        return instance
-
-class axis(Enum):
-    HORIZONTAL = "horizontal"
-    VERTICAL = "vertical"
-
-
-class spacing(Enum):
-    MIN = "min"
-    HALF = "half"
-    MAX = "max"
-    MANUAL = "manual"
-
-
-class alignment(Enum):
-    LEFT = "left"
-    RIGHT = "right"
-    CENTER = "center"
-    TOP = "top"
-    BOTTOM = "bottom"
-    TOPLEFT = "topleft"
-    TOPRIGHT = "topright"
-    MIDLEFT = "midleft"
-    MIDRIGHT = "midright"
-    MIDTOP = "midtop"
-    MIDBOTTOM = "midbottom"
-    BOTTOMLEFT = "bottomleft"
-    BOTTOMRIGHT = "bottomright"
-
-
-class direction(Enum):
-    LEFT = 0
-    UP = 1
-    RIGHT = 2
-    DOWN = 3
-
-
-class drawMode(Enum):
-    SOLID = 0
-    TEXTURED = 1
-
-
-class debugMode(Enum):
-    HIDDEN = 0
-    DEBUGGER = 1
-    OUTLINES = 2
-
-
-class actionType(Enum):
-    INSTANTANEOUS = 0
-    CONTINUOUS = 1
-    HOLDING = 2
-
-
-class textMode(Enum):
-    ALPHABETICAL = 0
-    NUMERICAL = 1
-    ALPHANUMERICAL = 3
-
-
-

batFramework/fontManager.py

@@ -1,65 +0,0 @@
-from .utils import Singleton
-
-# put font stuff here later
-import pygame
-import os
-import batFramework as bf
-
-
-class FontManager(metaclass=Singleton):
-    def __init__(self):
-        pygame.font.init()
-        self.DEFAULT_FONT_SIZE = 16
-        self.MIN_FONT_SIZE = 8
-        self.MAX_FONT_SIZE = 64
-        self.DEFAULT_ANTIALIAS = False
-        self.FONTS = {}
-
-    def set_default_antialias(self, value: bool):
-        self.DEFAULT_ANTIALIAS = value
-
-    def set_default_text_size(self, size: int):
-        self.DEFAULT_FONT_SIZE = size
-
-    def init_font(self, raw_path: str | None):
-        try:
-            if raw_path is not None:
-                self.load_font(raw_path if raw_path else None, None)
-            self.load_font(raw_path)
-        except FileNotFoundError:
-            self.load_sysfont(raw_path)
-            self.load_sysfont(raw_path, None)
-
-    def load_font(self, path: str | None, name: str | None = ""):
-        if path is not None:
-            path = bf.ResourceManager().get_path(path)  # convert path if given
-        filename = None
-        if path is not None:
-            filename = os.path.basename(path).split(".")[0]
-
-        # get filename if path is given, else None
-        if name != "":
-            filename = name  # if name is not given, name is the filename
-        self.FONTS[filename] = {}
-        # fill the dict
-        for size in range(self.MIN_FONT_SIZE, self.MAX_FONT_SIZE+1, 2):
-            self.FONTS[filename][size] = pygame.font.Font(path, size=size)
-
-    def load_sysfont(self, font_name: str | None, key: str | None = ""):
-        if key == "":
-            key = font_name
-        if font_name is None or pygame.font.match_font(font_name) is None:
-            raise FileNotFoundError(f"Requested font '{font_name}' was not found")
-        self.FONTS[font_name] = {}
-
-        for size in range(self.MIN_FONT_SIZE, self.MAX_FONT_SIZE+1, 2):
-            self.FONTS[key][size] = pygame.font.SysFont(font_name, size=size)
-
-    def get_font(
-        self, name: str | None = None, text_size: int = 12
-    ) -> pygame.Font | None:
-        if not name in self.FONTS:
-            return None
-        if not text_size in self.FONTS[name]:
-            return None
-        return self.FONTS[name][text_size]

batFramework/gui/animatedLabel.py

@@ -1,89 +0,0 @@
-from .label import Label
-import batFramework as bf
-from typing import Self,Callable,Any
-
-
-class AnimatedLabel(Label):
-    def __init__(self,text="") -> None:
-        self.cursor_position: float = 0.0
-        self.text_speed: float = 20.0
-        self.is_over: bool = True
-        self.is_paused: bool = False
-        self.original_text = ""
-        self.end_callback : Callable[[],Any]= None
-        self.set_autoresize(False)
-        self.set_alignment(bf.alignment.LEFT)
-        super().__init__("")
-        self.set_text(text)
-
-    def __str__(self) -> str:
-        return "AnimatedLabel"
-
-    def set_end_callback(self,callback:Callable[[],Any]):
-        self.end_callback = callback
-
-    def pause(self) -> Self:
-        self.is_paused = True
-        return self
-
-    def resume(self) -> Self:
-        self.is_paused = False
-        return self
-
-    def set_text_speed(self, speed: float) -> Self:
-        self.text_speed = speed
-        return self
-
-    def cut_text_to_width(self, text: str) -> list[str]:
-        w = self.get_inner_width()
-        if text == "" or not self.font_object or w < self.font_object.point_size:
-            return [text]
-        left = 0
-        for index in range(len(text)):
-            width = self.font_object.size(text[left:index])[0]
-
-            if width > w:
-                cut_point_start = index - 1
-                cut_point_end = index - 1
-                last_space = text.rfind(" ", 0, cut_point_start)
-                last_nline = text.rfind("\n", 0, cut_point_start)
-
-                if last_space != -1 or last_nline != -1:  # space was found !:
-                    cut_point_start = max(last_space, last_nline)
-                    cut_point_end = cut_point_start + 1
-                res = [text[:cut_point_start].strip()]
-                res.extend(self.cut_text_to_width(text[cut_point_end:].strip()))
-                return res
-            elif text[index] == "\n":
-                left = index
-        return [text]
-
-
-    def _set_text_internal(self,text:str)->Self:
-        super().set_text(text)
-        return self
-
-    def set_text(self,text:str)->Self:
-        self.original_text = text
-        self.is_over = False
-        self.cursor_position = 0
-
-    def set_size(self, size):
-        super().set_size(size)
-        self._set_text_internal('\n'.join(self.cut_text_to_width(self.original_text[: int(self.cursor_position)])))
-
-    def do_update(self, dt):
-        if self.is_over:
-            return
-        if not self.is_over and self.cursor_position == len(self.original_text):
-            if len(self.original_text) == 0:
-                self._set_text_internal("")
-            self.is_over = True
-            if self.end_callback is not None:
-                self.end_callback()
-            return
-        self.cursor_position = min(
-            self.cursor_position + self.text_speed * dt, len(self.original_text)
-        )
-        # self.set_text(self.original_text[: int(self.cursor_position)])
-        self._set_text_internal('\n'.join(self.cut_text_to_width(self.original_text[: int(self.cursor_position)])))