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

batFramework/cutsceneBlocks.py

@@ -1,176 +0,0 @@
-import batFramework as bf
-from .cutscene import Cutscene,CutsceneManager
-
-
-# Define the base CutsceneBlock class
-class CutsceneBlock:
-    """
-    Base class for cutscene blocks. Represents a unit of action in a cutscene.
-    """
-
-    # Constructor for the CutsceneBlock
-    def __init__(self) -> None:
-        # Callback function, parent cutscene, and state variables
-        self.callback = None
-        self.parent_cutscene: Cutscene = None
-        self.get_flag = CutsceneManager().get_flag
-        self.ended = False
-        self.started = False
-
-    def get_scene_at(self,index):
-        return bf.CutsceneManager().manager._scenes[index]
-
-    def set_scene(self,name,index=0):
-        return CutsceneManager().manager.set_scene(name,index)
-    
-    def get_current_scene(self):
-        return CutsceneManager().manager.get_current_scene()
-    
-    def get_scene(self,name):
-        return CutsceneManager().manager.get_scene(name)
-    
-    # Set the parent cutscene for this block
-    def set_parent_cutscene(self, parent):
-        """
-        Set the parent cutscene for this block.
-
-        Args:
-            parent: The parent cutscene object.
-        """
-        self.parent_cutscene = parent
-
-    # Process an event (placeholder implementation, to be overridden in subclasses)
-    def process_event(self, event):
-        """
-        Process an event for this cutscene block.
-
-        Args:
-            event: The event to be processed.
-        """
-        pass
-
-    # Update the block (placeholder implementation, to be overridden in subclasses)
-    def update(self, dt):
-        """
-        Update the cutscene block.
-
-        Args:
-            dt: Time elapsed since the last update.
-        """
-        pass
-
-    # Start the block
-    def start(self):
-        """
-        Start the cutscene block.
-        """
-        self.started = True
-
-    # Mark the block as ended
-    def end(self):
-        """
-        Mark the cutscene block as ended.
-        """
-        self.ended = True
-
-    # Check if the block has ended
-    def has_ended(self):
-        """
-        Check if the cutscene block has ended.
-
-        Returns:
-            bool: True if the block has ended, False otherwise.
-        """
-        return self.ended
-
-
-# Define the ParallelBlock class, a type of CutsceneBlock
-class ParallelBlock(CutsceneBlock):
-    """
-    Represents a parallel execution block for multiple Cutscene blocks.
-    """
-
-    # Constructor for ParallelBlock, taking a variable number of blocks as arguments
-    def __init__(self, *blocks) -> None:
-        super().__init__()
-        # List of blocks to run in parallel
-        self.blocks: list[CutsceneBlock] = blocks
-
-    # Start the parallel block (override the base class method)
-    def start(self):
-        """
-        Start the parallel execution block.
-        """
-        super().start()
-        # Start each block in parallel
-        for block in self.blocks:
-            block.start()
-
-    # Process an event for each block in parallel
-    def process_event(self, event):
-        """
-        Process an event for each block in the parallel execution block.
-
-        Args:
-            event: The event to be processed.
-        """
-        _ = [b.process_event(event) for b in self.blocks]
-
-    # Update each block in parallel
-    def update(self, dt):
-        """
-        Update each block in the parallel execution block.
-
-        Args:
-            dt: Time elapsed since the last update.
-        """
-        _ = [b.update(dt) for b in self.blocks]
-
-    # Check if all blocks have ended
-    def has_ended(self):
-        """
-        Check if all blocks in the parallel execution block have ended.
-
-        Returns:
-            bool: True if all blocks have ended, False otherwise.
-        """
-        return all(b.has_ended() for b in self.blocks)
-
-
-# Define the SceneTransitionBlock class, a type of CutsceneBlock
-class SceneTransitionBlock(CutsceneBlock):
-    """
-    Represents a scene transition Cutscene block.
-    """
-
-    # Constructor for SceneTransitionBlock
-    def __init__(self, scene, transition, duration, **kwargs) -> None:
-        super().__init__()
-        # Target scene, transition type, duration, and additional keyword arguments
-        self.target_scene = scene
-        self.transition = transition
-        self.duration = duration
-        self.kwargs = kwargs
-        # Timer to handle the end of the transition
-        self.timer = bf.Timer(name = "scene_transition_block",duration=duration, end_callback=self.end)
-
-    # Start the scene transition block
-    def start(self):
-        """
-        Start the scene transition block.
-        """
-        super().start()
-        print(f"transition to {scene}")
-
-        # Initiate the scene transition
-        if self.get_current_scene()._name == self.target_scene:
-            self.end()
-            return
-        CutsceneManager().manager.transition_to_scene(
-            self.target_scene, self.transition, duration=self.duration, **self.kwargs
-        )
-        # Start the timer to handle the end of the transition
-        self.timer.start()
-
-    def end(self):
-        return super().end()

batFramework/debugger.py

@@ -1,48 +0,0 @@
-import batFramework as bf
-import pygame
-
-
-class Debugger(bf.Label):
-    def __init__(self, manager) -> None:
-        super().__init__()
-        self.manager: bf.Manager = manager
-        self.refresh_rate = 0
-        self._refresh_counter = 0
-        self.dynamic_data = {}
-        self.static_data = {}
-        self.render_order = 99
-        self.set_outline_color((20, 20, 20))
-        # self.set_background_color((0,0,0,0))
-        self.set_text_color("white")
-        # self.set_padding((30,30))
-        self.set_refresh_rate(20)
-        self.add_dynamic_data("FPS", lambda: str(round(self.manager.get_fps())))
-        self.add_dynamic_data("BLITS", lambda: str(self.parent_scene.blit_calls))
-        self.set_visible(False)
-
-    def set_refresh_rate(self, val: int):
-        self.refresh_rate = val
-
-    def update(self, dt: float):
-        visible = self.manager._debugging == 1
-        self.set_visible(visible)
-        if not visible:
-            return
-        self._refresh_counter -= dt * 60
-        if self._refresh_counter < 0:
-            self._refresh_counter = self.refresh_rate
-            self._refresh_debug_info()
-
-    def add_dynamic_data(self, key, func):
-        self.dynamic_data[key] = func
-
-    def set_static_data(self, key, value):
-        self.static_data[key] = value
-
-    def _refresh_debug_info(self):
-        lines = []
-        lines.extend([f"{key}:{value}" for key, value in self.static_data.items()])
-        lines.extend([f"{key}:{func()}" for key, func in self.dynamic_data.items()])
-        debug_text = "\n".join(lines)
-        self.set_text(debug_text)
-        self.update_surface()  # Update the surface after modifying the text

batFramework/easing.py

@@ -1,71 +0,0 @@
-from enum import Enum
-import pygame
-import batFramework as bf
-
-class Easing(Enum):
-    EASE_IN     = (0.12, 0, 0.39, 0)
-    EASE_OUT    = (0.61, 1, 0.88, 1)
-    EASE_IN_OUT = (0.37, 0, 0.63, 1)
-    EASE_IN_OUT_ELASTIC = (.7,-0.5,.3,1.5)
-    LINEAR      = (1, 1, 0, 0)
-    # Add more easing functions as needed
-
-    def __init__(self, *control_points):
-        self.control_points = control_points
-
-class EasingAnimation(bf.Timer):
-    _cache = {}
-    def __init__(
-        self,
-        name:str=None,
-        easing_function:Easing=Easing.LINEAR,
-        duration:int=100,
-        update_callback=None,
-        end_callback=None,
-        loop:bool=False,
-        reusable:bool=False
-    ):
-        self.easing_function = easing_function
-        self.update_callback = update_callback
-        self.value = 0.0
-        super().__init__(name,duration,loop,end_callback,reusable)
-        
-    def get_value(self):
-        return self.value
-
-    def start(self):
-        self.value =  0
-        super().start() # self.elapsed_progress set to 0 here    
-        
-    def update(self)->bool:
-        if super().update():
-            return True# If timer ended now, end() is called. So don't process value.  
-        self._process_value()
-        # if self.name == 0: print("UPDATING (callback) in easing")
-        if self.update_callback: self.update_callback(self.value)
-        return False
-
-    def end(self):
-        # Call update 1 last time with the last value
-
-        self.elapsed_progress = 1
-        self._process_value()
-        if self.update_callback: self.update_callback(self.value)
-        self.value =  0
-        super().end() # sets elapsed_progress to 0
-
-    def _process_value(self):
-        p0, p1, p2, p3 = self.easing_function.control_points
-        cache_key = (self.elapsed_progress, p0, p1, p2, p3)
-        if cache_key in EasingAnimation._cache:
-            y = EasingAnimation._cache[cache_key]
-        else:
-            t = self.elapsed_progress
-            t_inv = 1.0 - t
-            t2 = t * t
-            t3 = t * t2
-            t_inv2 = t_inv * t_inv
-
-            y = 3 * t_inv2 * t * p1 + 3 * t_inv * t2 * p3 + t3
-            EasingAnimation._cache[cache_key] = y
-        self.value = y

batFramework/gui/constraints.py

@@ -1,204 +0,0 @@
-from .widget import Widget
-import batFramework as bf
-
-
-class Constraint:
-    def __init__(self,name="Constraint", priority=0):
-        self.priority = priority
-        self.name = name
-    def set_priority(self, priority)->"Constraint":
-        self.priority = priority
-        return self
-    def to_string(self)->str:
-        return f"{self.name.upper()}"
-        
-    def evaluate(self, parent_widget:Widget, child_widget:Widget) -> bool:
-        raise NotImplementedError("Subclasses must implement evaluate method")
-
-    def apply(self, parent_widget:Widget, child_widget:Widget=None) -> bool:
-        if not self.evaluate(parent_widget, child_widget):
-            self.apply_constraint(parent_widget, child_widget)
-            return False
-        return True
-        
-    def apply_constraint(self, parent_widget:Widget, child_widget:Widget):
-        raise NotImplementedError("Subclasses must implement apply_constraint method")
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-class ConstraintMinWidth(Constraint):
-    def __init__(self, width):
-        super().__init__(name="min_width")
-        self.min_width = width
-
-    def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.width >= self.min_width
-
-    def apply_constraint(self, parent_widget, child_widget):
-        if not self.evaluate(parent_widget, child_widget):
-            child_widget.set_size(self.min_width,child_widget.rect.h)
-
-
-            
-    
-class ConstraintCenterX(Constraint):
-    def __init__(self):
-        super().__init__(name="centerx")
-
-    def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.centerx == parent_widget.get_content_center()[0]
-
-    def apply_constraint(self,parent_widget,child_widget):
-        if not self.evaluate(parent_widget,child_widget):
-            child_widget.set_center(parent_widget.get_content_center()[0],child_widget.rect.centery)
-
-class ConstraintCenterY(Constraint):
-    def __init__(self):
-        super().__init__(name="centery")
-
-    def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.centery == parent_widget.get_content_center()[1]
-
-    def apply_constraint(self,parent_widget,child_widget):
-        if not self.evaluate(parent_widget,child_widget):
-            child_widget.set_center(child_widget.rect.centerx,parent_widget.get_content_center()[1])
-
-class ConstraintCenter(Constraint):
-    def __init__(self):
-        super().__init__(name="center")
-
-    def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.center == parent_widget.get_content_center()
-
-    def apply_constraint(self,parent_widget,child_widget):
-        if not self.evaluate(parent_widget,child_widget):
-            child_widget.set_center(*parent_widget.get_content_center())
-
-class ConstraintPercentageWidth(Constraint):
-    def __init__(self,percentage:float,keep_autoresize:bool=True):
-        super().__init__(name="percentage_width")
-        self.percentage:float = percentage
-        self.keep_autoresize: bool = keep_autoresize
-    def to_string(self)->str:
-        return f"{super().to_string()}.[{self.percentage},{self.keep_autoresize}]"
-    def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.width == round(parent_widget.get_content_width() * self.percentage)
-
-    def apply_constraint(self,parent_widget,child_widget):
-        if not self.evaluate(parent_widget,child_widget):
-            if child_widget.autoresize:
-                if self.keep_autoresize:
-                    print(f"Warning: Constraint on {child_widget.to_string()} can't resize, autoresize set to True")
-                    return 
-                child_widget.set_autoresize(False)
-            child_widget.set_size(round(parent_widget.get_content_width() * self.percentage) ,child_widget.rect.h)
-
-
-class ConstraintPercentageHeight(Constraint):
-    def __init__(self,percentage:float,keep_autoresize:bool=True):
-        super().__init__(name="percentage_height")
-        self.percentage:float = percentage
-        self.keep_autoresize: bool = keep_autoresize
-
-    def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.height == round(parent_widget.get_content_height() * self.percentage)
-
-    def apply_constraint(self,parent_widget,child_widget):
-        if not self.evaluate(parent_widget,child_widget):
-            if child_widget.autoresize:
-                if self.keep_autoresize:
-                    print(f"Warning: Constraint on {child_widget.to_string()} can't resize, autoresize set to True")
-                    return 
-                child_widget.set_autoresize(False)
-            child_widget.set_size(child_widget.rect.w,round(parent_widget.get_content_height() * self.percentage))
-
-class ConstraintHeight(Constraint):
-    def __init__(self,height:float):
-        if height < 0 :
-            raise ValueError("height can't be negative")
-        super().__init__(name="height")
-        self.height = height
-
-    def to_string(self)->str:
-        return f"{super().to_string()}.({self.height})"
-
-    def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.height == self.height
-
-    def apply_constraint(self,parent_widget,child_widget):
-        if not self.evaluate(parent_widget,child_widget):
-            child_widget.set_size(child_widget.rect.w,self.height)
-
-class ConstraintWidth(Constraint):
-    def __init__(self,width:float):
-        if width < 0 :
-            raise ValueError("width can't be negative")
-        super().__init__(name="width")
-        self.width = width
-
-    def to_string(self)->str:
-        return f"{super().to_string()}.({self.width})"
-
-    def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.width == self.width
-
-    def apply_constraint(self,parent_widget,child_widget):
-        if not self.evaluate(parent_widget,child_widget):
-            child_widget.set_size(self.width,child_widget.rect.h)
-
-
-class ConstraintAspectRatio(Constraint):
-    def __init__(self,ratio:int|float=1):
-        super().__init__(name="aspect_ratio")
-        if isinstance(ratio, float|int):
-            self.ratio = ratio
-        elif isinstance(ratio,Widget):
-            self.ratio = ratio.rect.w / ratio.rect.h
-        else:
-            raise TypeError(f"Ratio must be float or Widget")
-    def evaluate(self, parent_widget,child_widget):
-        return  self.ratio  ==  child_widget.rect.w / child_widget.rect.h
-        
-    def apply_constraint(self,parent_widget,child_widget):
-        if not self.evaluate(parent_widget,child_widget):
-            return # TODO
-    
-class ConstraintAnchorBottom(Constraint):
-    def __init__(self):
-        super().__init__(name="anchor_bottom")
-        
-    def evaluate(self, parent_widget,child_widget):
-        return  child_widget.rect.bottom == parent_widget.rect.bottom
-        
-    def apply_constraint(self,parent_widget,child_widget):
-        if not self.evaluate(parent_widget,child_widget):
-            child_widget.set_y(parent_widget.get_content_bottom() - child_widget.rect.h)
-
-
-class ConstraintAnchorTopRight(Constraint):
-    def __init__(self):
-        super().__init__(name="anchor_topright")
-        
-    def evaluate(self, parent_widget,child_widget):
-        return  child_widget.rect.topright == parent_widget.rect.topright
-        
-    def apply_constraint(self,parent_widget,child_widget):
-        if not self.evaluate(parent_widget,child_widget):
-            child_widget.set_position(parent_widget.get_content_right()-child_widget.rect.w, parent_widget.get_content_top())
-
-
-
-

batFramework/gui/frame.py

@@ -1,19 +0,0 @@
-import batFramework as bf
-from .shape import Shape
-import pygame
-
-
-class Frame(Shape):
-    def __init__(self,width:float,height:float):
-        super().__init__(width,height)
-        self.set_debug_color("magenta")
-
-    def to_string_id(self)->str:
-        return "Frame"
-
-    def children_modified(self)->None:
-        print(self.children)
-        self.set_size(
-            *self.inflate_rect_by_padding(self.rect.unionall(list(c.rect for c in self.children))).size
-        )
-        super().children_modified()

batFramework/particles.py

@@ -1,77 +0,0 @@
-import batFramework as bf
-import pygame
-from pygame.math import Vector2
-
-
-class Particle:
-    def __init__(
-        self,
-        start_pos: tuple[float, float],
-        start_vel: tuple[float, float],
-        duration=1000,
-        color=None,
-        size = (4,4)
-    ):
-        self.rect = pygame.FRect(*start_pos, 0, 0)
-        self.surface = pygame.Surface(size).convert()
-        if color:
-            self.surface.fill(color)
-        self.velocity = Vector2(*start_vel)
-        self.start_time = pygame.time.get_ticks()
-        self.duration = duration
-        self.dead = False
-        self.progression = 0
-        self.z_depth = 1
-
-    def update(self, dt):
-        if self.dead:
-            return
-        elapsed_time = pygame.time.get_ticks() - self.start_time
-        self.progression = elapsed_time / self.duration
-        self.dead = elapsed_time >= self.duration
-        self.rect.center += self.velocity * dt
-        self.update_surface()
-
-    def kill(self):
-        self.dead = True
-
-    def update_surface(self):
-        self.surface.set_alpha(255 - int(self.progression * 255))
-
-
-class ParticleManager(bf.Entity):
-    def __init__(self) -> None:
-        super().__init__(size=bf.const.RESOLUTION)
-        self.particles: list[Particle] = []
-
-    def get_bounding_box(self):
-        for particle in self.particles:
-            yield particle.rect
-
-    def add_particle(self, particle_class=Particle, **kwargs):
-        self.particles.append(particle_class(**kwargs))
-
-
-    def clear(self):
-        self.particles = []
-        
-
-    def update(self, dt: float):
-        particles_to_remove = []
-        for particle in self.particles:
-            particle.update(dt)
-            if particle.dead:
-                particles_to_remove.append(particle)
-        for p in particles_to_remove:
-            self.particles.remove(p)
-
-    def draw(self, camera) -> bool:
-        camera.surface.fblits(
-            [
-                (
-                    p.surface,
-                    tuple(round(i * self.z_depth) for i in camera.transpose(self.rect).topleft)
-                ) for p in self.particles
-            ]
-        )
-        return len(self.particles)

batFramework/time.py

@@ -1,75 +0,0 @@
-import pygame
-import batFramework as bf
-
-class Timer:
-    _highest_count = 0
-    def __init__(self, name=None, duration=1000, loop=False, end_callback=None,reusable:bool=False):
-        # Initialize timer properties
-        self.start_time = None
-        self.stopped = True
-        self.name = name if name is not None else self._highest_count
-        Timer._highest_count += 1
-        self.duration = duration
-        self.loop = loop
-        self.elapsed_progress = 0.0
-        self.end_callback = end_callback
-        self.reusable:bool = reusable
-    def start(self):
-        # Start the timer and set the start time
-        if self.start_time is None:
-            Time().add_timer(self)
-            
-        self.start_time = pygame.time.get_ticks()
-        self.stopped = False
-        self.elapsed_progress = 0.0
-        
-    def update(self):
-        if self.stopped : return False
-        current_time = pygame.time.get_ticks()
-        if self.elapsed_progress < 1:
-            # Calculate elapsed progress
-            self.elapsed_progress = (current_time - self.start_time) / self.duration            
-            if self.elapsed_progress >= 1:
-                # Timer has completed
-                self.end()
-                return True
-        elif self.loop:
-            # If looping, restart the timer
-             self.start()
-        return False
-
-    def stop(self):
-        # Stop the timer
-        self.stopped = True
-
-    def end(self):
-        self.elapsed_progress = 1
-        self.stopped = False
-        if self.end_callback:
-            self.end_callback()
-
-    def ended(self):
-        if self.start_time is None:
-            return False
-        return (not self.loop) and (self.elapsed_progress >= 1) and (not self.stopped) and not self.reusable
-
-
-class Time(metaclass=bf.Singleton):
-    def __init__(self):
-        # Initialize the Time class with a dictionary of timers
-        self.timers = {}
-
-    def add_timer(self, timer):
-        # Add a timer to the dictionary
-        self.timers[timer.name] = timer
-
-    def update(self):
-        # Update all timers and remove completed ones
-        for timer in list(self.timers.values()):
-            timer.update()
-
-        to_remove = [name for name, timer in self.timers.items() if timer.ended()]
-
-        for name in to_remove:
-            # print(self.timers.pop(name).name,"removed !")
-            self.timers.pop(name)