batframework 1.0.9a6__py3-none-any.whl → 1.0.9a8__py3-none-any.whl

batFramework/templates/controller.py

@@ -0,0 +1,97 @@
+import batFramework as bf
+import pygame
+
+class PlatformController(bf.DynamicEntity):
+    def __init__(self,*args,**kwargs):
+        super().__init__(*args,**kwargs)
+        self.control = bf.ActionContainer()
+        self.speed = 500
+        self.acceleration = 100
+        self.jump_force = -500
+        self.gravity = 1200
+        self.on_ground = False
+        self.friction = 0.7
+        
+    def do_reset_actions(self):
+        self.control.reset()
+
+    def do_process_actions(self, event):
+        self.control.process_event(event)
+
+    def check_collision_y(self):
+        pass
+
+    def check_collision_x(self):
+        pass
+
+    def update(self, dt):
+        super().update(dt)
+        self.velocity.x *= self.friction
+        if abs(self.velocity.x) <= 0.01:
+            self.velocity.x = 0
+        if not self.on_ground:
+            self.velocity.y += self.gravity * dt
+        if self.control.is_active("left"):
+            self.velocity.x -= self.acceleration
+        if self.control.is_active("right"):
+            self.velocity.x += self.acceleration
+        if self.on_ground and self.control.is_active("jump") :
+            self.velocity.y = self.jump_force
+            self.on_ground = False
+        
+        self.velocity.x = pygame.math.clamp(self.velocity.x,-self.speed,self.speed)
+        self.rect.x += self.velocity.x * dt
+        self.check_collision_x()
+        self.rect.y += self.velocity.y * dt
+        self.check_collision_y()
+
+
+
+class TopDownController(bf.DynamicEntity):
+    def __init__(self,*args,**kwargs):
+        super().__init__(*args,**kwargs)
+        self.control = bf.ActionContainer()
+        self.input_velocity = pygame.Vector2()
+        self.speed = 500
+        self.acceleration = 100
+        self.friction = 0
+        
+    def do_reset_actions(self):
+        self.control.reset()
+
+    def do_process_actions(self, event):
+        self.control.process_event(event)
+
+    def check_collision_y(self):
+        pass
+
+    def check_collision_x(self):
+        pass
+
+    def update(self, dt):
+        super().update(dt)
+        self.input_velocity.update(0,0)
+        self.velocity *= self.friction
+        
+        if abs(self.velocity.x) <= 0.01:
+            self.velocity.x = 0
+        if self.control.is_active("left"):
+            self.input_velocity[0] = -self.acceleration
+        if self.control.is_active("right"):
+            self.input_velocity[0] =  self.acceleration
+        if self.control.is_active("up"):
+            self.input_velocity[1] = -self.acceleration
+        if self.control.is_active("down"):
+            self.input_velocity[1] =  self.acceleration
+
+        if self.input_velocity:
+            self.input_velocity.normalize_ip()
+
+        self.velocity += self.input_velocity * self.acceleration
+        self.velocity.clamp_magnitude_ip(self.speed)
+
+
+        self.rect.x += self.velocity.x * dt
+        self.check_collision_x()
+        self.rect.y += self.velocity.y * dt
+        self.check_collision_y()

batFramework/timeManager.py

@@ -1,12 +1,11 @@
 import batFramework as bf
 from typing import Callable, Union, Self,Any
 
-
 class Timer:
     _count: int = 0
     _available_ids: set[int] = set()
 
-    def __init__(self, duration: Union[float, int], end_callback: Callable[[],Any], loop: bool = False, register: str = "global") -> None:
+    def __init__(self, duration: float, end_callback: Callable[[], Any], loop: int = 0, register: str = "global") -> None:
         if Timer._available_ids:
             self.uid = Timer._available_ids.pop()
         else:
@@ -14,85 +13,133 @@ class Timer:
             Timer._count += 1
 
         self.register = register
-        self.duration: int | float = duration
+        self.duration: float = duration
         self.end_callback = end_callback
 
-        self.elapsed_time: float = -1
+        self.elapsed_time: float = 0
         self.is_over: bool = False
-        self.is_looping: bool = loop
+        self.loop: int = loop  # Number of loops (-1 for infinite)
         self.is_paused: bool = False
         self.do_delete: bool = False
+        self.is_stopped: bool = True
 
-    def __bool__(self)->bool:
-        return self.elapsed_time==-1 or self.is_over
+    def __bool__(self) -> bool:
+        return self.elapsed_time != -1 and self.is_over
 
     def __str__(self) -> str:
-        return f"Timer ({self.uid}) {self.elapsed_time}/{self.duration} | {'loop ' if self.is_looping else ''} {'(D) ' if self.do_delete else ''}"
+        loop_info = "infinite" if self.loop == -1 else f"{self.loop} loops left"
+        return f"Timer ({self.uid}) {self.elapsed_time}/{self.duration} | {loop_info} {'(D) ' if self.do_delete else ''}"
 
     def stop(self) -> Self:
-        self.elapsed_time = -1
-        self.is_over = False
+        """
+        Cancels all progression and stops the timer.
+        Does not mark it for deletion and does not call the end_callback.
+        Prevents automatic restart if looping.
+        """
+        self.is_stopped = True
         self.is_paused = False
+        self.is_over = False
+        self.elapsed_time = 0
         return self
 
     def start(self, force: bool = False) -> Self:
-        if self.elapsed_time != -1 and not force:
+        """
+        Starts the timer only if not already started (unless force is used, which resets it).
+        """
+        if self.elapsed_time > 0 and not force:
             return self
-        if not bf.TimeManager().add_timer(self,self.register):
+        if not bf.TimeManager().add_timer(self, self.register):
             return self
         self.elapsed_time = 0
         self.is_paused = False
         self.is_over = False
+        self.is_stopped = False
         return self
 
     def pause(self) -> Self:
+        """
+        Momentarily stops the timer until resume is called.
+        """
         self.is_paused = True
         return self
 
     def resume(self) -> Self:
+        """
+        Resumes from a paused state.
+        """
         self.is_paused = False
         return self
 
     def delete(self) -> Self:
+        """
+        Marks the timer for deletion.
+        """
         self.do_delete = True
         return self
 
     def has_started(self) -> bool:
-        return self.elapsed_time != -1
+        """
+        Returns True if the timer has started.
+        """
+        return not self.is_stopped
 
     def get_progression(self) -> float:
-        if self.elapsed_time < 0:
+        """
+        Returns the progression of the timer (0 to 1) as a float.
+        """
+        if self.is_stopped:
             return 0
         if self.elapsed_time >= self.duration:
             return 1
         return self.elapsed_time / self.duration
 
     def update(self, dt) -> None:
-        if self.elapsed_time < 0 or self.is_paused or self.is_over:
+        if self.is_stopped or self.is_paused or self.is_over:
             return
         self.elapsed_time += dt
-        # print("update :",self.elapsed_time,self.duration)
         if self.get_progression() == 1:
             self.end()
 
     def end(self):
+        """
+        Ends the timer progression (calls the end_callback function).
+        Is called automatically once the timer is over.
+        Will not mark the timer for deletion.
+        If it is looping, it will restart the timer **only if it wasn't stopped**.
+        """
+        self.is_over = True
         if self.end_callback:
             self.end_callback()
-        self.elapsed_time = -1
-        self.is_over = True
-        if self.is_looping:
+
+        # Handle looping
+        if self.loop == -1:  # Infinite looping
+            self.elapsed_time = 0
             self.start()
             return
+        elif self.loop > 0:  # Decrease loop count and restart
+            self.loop -= 1
+            self.elapsed_time = 0
+            self.start()
+            return
+
+        # Stop the timer if no loops are left
+        self.is_stopped = True
 
     def should_delete(self) -> bool:
+        """
+        Method that returns if the timer is to be deleted.
+        Required for timer management.
+        """
         return self.is_over or self.do_delete
 
     def _release_id(self):
         Timer._available_ids.add(self.uid)
 
-
 class SceneTimer(Timer):
-    def __init__(self, duration: float | int, end_callback, loop: bool = False, scene_name:str = "global") -> None:
+    """
+    A timer that is only updated while the given scene is active (being updated)
+    """
+    def __init__(self, duration: float | int, end_callback, loop: int = 0, scene_name:str = "global") -> None:
         super().__init__(duration, end_callback, loop, scene_name)
 
 class TimeManager(metaclass=bf.Singleton):
@@ -125,6 +172,13 @@ class TimeManager(metaclass=bf.Singleton):
         if name not in self.registers:
             self.registers[name] = TimeManager.TimerRegister(active)
 
+    def remove_register(self, name):
+        if name not in self.registers:
+            return
+        
+        self.registers.pop(name)
+
+
     def add_timer(self, timer, register="global") -> bool:
         if register in self.registers:
             self.registers[register].add_timer(timer)
@@ -136,7 +190,7 @@ class TimeManager(metaclass=bf.Singleton):
         return [t for t in self.registers.values() if t.active]
 
     def update(self, dt):
-        for register_name, register in self.registers.items():
+        for register in self.registers.values():
             if register.active:
                 register.update(dt)
 

batFramework/transition.py

@@ -10,39 +10,23 @@ Both surfaces to transition need to be the same size
 
 class Transition:
     def __init__(
-        self, duration: float, easing_function: bf.easing = bf.easing.LINEAR
+        self, duration: float=1, easing: bf.easing = bf.easing.LINEAR
     ) -> None:
         """
         duration : time in seconds
         easing function : controls the progression rate
         """
         self.duration: float = duration
-        self.controller = bf.EasingController(
-            easing_function,
-            duration,
-            update_callback=self.update,
-            end_callback=self.end,
+        self.controller = bf.EasingController( # main controller for the transition progression
+            duration,easing,
+            update_callback=self.update,end_callback=self.end,
         )
-        self.start_callback : Callable[[],Any] = None
-        self.update_callback : Callable[[float],Any]= None
-        self.end_callback : Callable[[],Any]= None
         self.source: pygame.Surface = None
         self.dest: pygame.Surface = None
+        self.is_over : bool = False # this flag tells the manager the transition is over 
 
     def __repr__(self) -> str:
-        return f"Transition {self.__class__},{self.duration}"
-
-    def set_start_callback(self, func : Callable[[],Any]) -> Self:
-        self.start_callback = func
-        return self
-
-    def set_update_callback(self, func : Callable[[float],Any]) -> Self:
-        self.update_callback = func
-        return self
-
-    def set_end_callback(self, func : Callable[[],Any]) -> Self:
-        self.end_callback = func
-        return self
+        return f"Transition ({self.__class__},{self.duration})"
 
     def set_source(self, surface: pygame.Surface) -> None:
         self.source = surface
@@ -51,127 +35,77 @@ class Transition:
         self.dest = surface
 
     def start(self):
-        if self.controller.has_started():
+        if self.controller.has_started(): # can't start again while it's in progress 
             return
-        if self.duration:
+        if self.duration: # start the transition
             self.controller.start()
-            if self.start_callback:
-                self.start_callback()
             return
 
+        # if no duration the transition is instantaneous
         self.controller.start()
-        if self.start_callback:
-            self.start_callback()
         self.controller.end()
-        self.update(1)
+        self.update(1)# to prevent weird behaviour, update once with progression at max value
         self.end()
 
     def update(self, progression: float) -> None:
-        if self.update_callback:
-            self.update_callback(progression)
+        pass
 
     def end(self):
         self.controller.stop()
-        if self.end_callback:
-            self.end_callback()
+        self.is_over = True
 
     def draw(self, surface: pygame.Surface) -> None:
         pass
 
-    def skip(self, no_callback: bool = False):
-        self.controller.stop()
-        if self.end_callback and (no_callback == False):
-            self.end_callback()
+    def skip(self):
+        self.end()
+
 
 
 class FadeColor(Transition):
-    def __init__(
-        self,
-        color: tuple,
-        middle_duration: float,
-        first_duration: float | None = None,
-        second_duration: float | None = None,
-        easing_function: bf.easing = bf.easing.LINEAR,
-    ) -> None:
-        super().__init__(0, easing_function)
-        if first_duration is None:
-            first_duration = middle_duration
-        if second_duration is None:
-            second_duration = middle_duration
-
-        self.first = Fade(first_duration)
-        self.second = Fade(second_duration)
+    def __init__(self,duration:float,color=(0,0,0),color_start:float=0.3,color_end:float=0.7, easing = bf.easing.LINEAR):
+        super().__init__(duration, easing)
         self.color = color
-        self.middle_duration = middle_duration
-        self.index = 0
-
-        self.timer = bf.Timer(middle_duration, self.transition_to_second)
-        self.first.set_end_callback(self.transition_to_middle)
-        self.second.set_end_callback(self.transition_to_end)
-
-    def transition_to_middle(self):
-        self.next_step(self.timer.start)
-
-    def transition_to_second(self):
-        self.next_step(self.second.start)
-
-    def transition_to_end(self):
-        self.next_step(self.end)
-
-    def next_step(self, callback : Callable[[],Any]=None) -> None:
-        self.index += 1
-        if callback:
-            callback()
-
-    def set_source(self, surface) -> None:
-        super().set_source(surface)
-        self.first.set_source(surface)
-
-    def set_dest(self, surface) -> None:
-        super().set_dest(surface)
-        self.second.set_dest(surface)
+        self.color_start = color_start
+        self.color_end = color_end
 
     def start(self):
-        if self.start_callback:
-            self.start_callback()
-
+        super().start()
         self.color_surf = pygame.Surface(self.source.get_size())
         self.color_surf.fill(self.color)
 
-        self.first.set_dest(self.color_surf)
-        self.second.set_source(self.color_surf)
-        self.first.start()
-
     def draw(self, surface):
-        if self.index == 0:
-            self.first.draw(surface)
-        elif self.index == 1:
-            surface.blit(self.color_surf, (0, 0))
-        else:
-            self.second.draw(surface)
-
-    def skip(self, no_callback: bool = False):
-        if not no_callback and self.end_callback:
-            self.end_callback()
-
-        self.first.controller.stop()
-        self.timer.stop()
-        self.second.controller.stop()
+        v = self.controller.get_value()
+        if v < self.color_start:
+            v = v/(self.color_start)
+            self.color_surf.set_alpha(255*v)
+            surface.blit(self.source)
+            surface.blit(self.color_surf)
 
+        elif v < self.color_end:
+            self.color_surf.set_alpha(255)
+            surface.blit(self.color_surf)
 
+        else:
+            v = (v-self.color_end)/(1-self.color_end)
+            surface.blit(self.color_surf)
+            self.dest.set_alpha(255*v)
+            surface.blit(self.dest)
 
 class Fade(Transition):
     def end(self):
         self.dest.set_alpha(255)
         return super().end()
 
+    def start(self):
+        super().start()
+
     def draw(self, surface):
         dest_alpha = 255 * self.controller.get_value()
         self.dest.set_alpha(dest_alpha)
         surface.blit(self.source, (0, 0))
         surface.blit(self.dest, (0, 0))
 
-
 class GlideRight(Transition):
     def draw(self, surface):
         width = surface.get_width()

batFramework/utils.py

@@ -1,5 +1,6 @@
 import pygame
 import batFramework as bf
+import math
 import random
 from .enums import *
 import re
@@ -8,7 +9,7 @@ from functools import cache
 if TYPE_CHECKING:
     from .drawable import Drawable
     from .entity import Entity
-
+from pygame.math import Vector2
 
 
 class Singleton(type):
@@ -236,12 +237,129 @@ class Utils:
 
         Args:
             margin (int): Margin from the screen edges, where the point won't be generated. 
-                        If margin is less than 0 or greater than the screen resolution, returns (0, 0).
+                        If margin is less than 0 or greater than half the screen resolution, returns (0, 0).
 
         Returns:
             tuple[int, int]: A tuple representing a random point (x, y) on the screen within the screen 
             resolution minus the margin.
         """
-        if margin < 0 or margin > bf.const.RESOLUTION[0] or margin > bf.const.RESOLUTION[1]:
+        if margin < 0 or margin > bf.const.RESOLUTION[0]//2 or margin > bf.const.RESOLUTION[1]//2:
             return 0, 0
         return random.randint(margin, bf.const.RESOLUTION[0] - margin), random.randint(margin, bf.const.RESOLUTION[1] - margin)
+
+    @staticmethod
+    def distance_point(a:tuple[float,float],b:tuple[float,float]):
+        return math.sqrt((a[0]-b[0]) ** 2 + (a[1]-b[1])**2)
+
+    @staticmethod
+    def rotate_point(point: Vector2, angle: float, center: Vector2) -> Vector2:
+        """Rotate a point around a center by angle (in degrees)."""
+        rad = math.radians(angle)
+        translated = point - center
+        rotated = Vector2(
+            translated.x * math.cos(rad) - translated.y * math.sin(rad),
+            translated.x * math.sin(rad) + translated.y * math.cos(rad)
+        )
+        return rotated + center
+
+ 
+    def draw_triangle(surface:pygame.Surface, color, rect:pygame.FRect|pygame.Rect, direction:bf.enums.direction=bf.enums.direction.RIGHT,width:int=0):
+        """
+        Draw a filled triangle inside a rectangle on a Pygame surface, pointing in the specified direction.
+        
+        Args:
+            surface: The Pygame surface to draw on.
+            color: The color of the triangle (e.g., (255, 0, 0) for red).
+            rect: A pygame.Rect object defining the rectangle's position and size.
+            direction: A string ('up', 'down', 'left', 'right') indicating the triangle's orientation.
+        """
+        # Define the three vertices of the triangle based on direction
+        rect = rect.copy()
+        rect.inflate_ip(-1,-1)
+        if direction == direction.UP:
+            points = [
+                (rect.left, rect.bottom),      # Bottom-left corner
+                (rect.right, rect.bottom),     # Bottom-right corner
+                (rect.centerx, rect.top)       # Top center (apex)
+            ]
+        elif direction == direction.DOWN:
+            points = [
+                (rect.left, rect.top),         # Top-left corner
+                (rect.right, rect.top),        # Top-right corner
+                (rect.centerx, rect.bottom)    # Bottom center (apex)
+            ]
+        elif direction == direction.LEFT:
+            points = [
+                (rect.right, rect.top),        # Top-right corner
+                (rect.right, rect.bottom),     # Bottom-right corner
+                (rect.left, rect.centery)      # Left center (apex)
+            ]
+        elif direction == direction.RIGHT:
+            points = [
+                (rect.left, rect.top),         # Top-left corner
+                (rect.left, rect.bottom),      # Bottom-left corner
+                (rect.right, rect.centery)     # Right center (apex)
+            ]
+        else:
+            raise ValueError("Invalid direction")
+
+        # Draw the filled triangle
+        pygame.draw.polygon(surface, color, points,width=width)
+
+    def draw_arc_by_points(surface, color, start_pos, end_pos, tightness=0.5, width=1, resolution=0.5):
+        """
+        Draw a smooth circular arc connecting start_pos and end_pos.
+        `tightness` controls curvature: 0 is straight line, 1 is semicircle, higher = more bulge.
+        Negative tightness flips the bulge direction.
+
+        Args:
+            surface     - pygame Surface
+            color       - RGB or RGBA
+            start_pos   - (x, y)
+            end_pos     - (x, y)
+            tightness   - curvature control, 0 = straight, 1 = half circle
+            width       - line width
+            resolution  - approx pixels per segment
+        Returns:
+            pygame.Rect bounding the drawn arc
+        """
+        p0 = pygame.Vector2(start_pos)
+        p1 = pygame.Vector2(end_pos)
+        chord = p1 - p0
+        if chord.length_squared() == 0:
+            return pygame.draw.circle(surface, color, p0, width // 2)
+
+        # Midpoint and perpendicular
+        mid = (p0 + p1) * 0.5
+        perp = pygame.Vector2(-chord.y, chord.x).normalize()
+
+        # Distance of center from midpoint, based on tightness
+        h = chord.length() * tightness
+        center = mid + perp * h
+
+        # Radius and angles
+        r = (p0 - center).length()
+        ang0 = math.atan2(p0.y - center.y, p0.x - center.x)
+        ang1 = math.atan2(p1.y - center.y, p1.x - center.x)
+
+        # Normalize sweep direction based on sign of tightness
+        sweep = ang1 - ang0
+        if tightness > 0 and sweep < 0:
+            sweep += 2 * math.pi
+        elif tightness < 0 and sweep > 0:
+            sweep -= 2 * math.pi
+
+        # Number of points
+        arc_len = abs(sweep * r)
+        segs = max(2, int(arc_len / max(resolution, 1)))
+
+        points = []
+        for i in range(segs + 1):
+            t = i / segs
+            a = ang0 + sweep * t
+            points.append((
+                center.x + math.cos(a) * r,
+                center.y + math.sin(a) * r
+            ))
+
+        return pygame.draw.lines(surface, color, False, points, width)

{batframework-1.0.9a6.dist-info → batframework-1.0.9a8.dist-info}/METADATA

@@ -1,15 +1,36 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: batframework
-Version: 1.0.9a6
+Version: 1.0.9a8
 Summary: Pygame framework for making games easier.
 Author-email: Turan Baturay <baturayturan@gmail.com>
+License: MIT License
+        
+        Copyright (c) [2023] [TURAN BATURAY]
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
 Project-URL: Homepage, https://github.com/TuranBaturay/batFramework
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
-License-File: LICENCE
+License-File: LICENSE
 Requires-Dist: pygame-ce
 
 # batFramework