batframework 1.0.8a3__py3-none-any.whl → 1.0.8a6__py3-none-any.whl

batFramework/scrollingSprite.py

@@ -99,17 +99,16 @@ class ScrollingSprite(bf.Sprite):
             x += self.original_width
         return self
 
-    def draw(self, camera: bf.Camera) -> int:
+    def draw(self, camera: bf.Camera) -> None:
         if not (
             self.visible
             and (self.surface is not None)
             and camera.rect.colliderect(self.rect)
         ):
-            return 0
-        self.surface.fill((0, 0, 0, 0))
-        self.surface.fblits(
-            [(self.original_surface, r) for r in self._get_mosaic_rect_list()]
+            return
+        # self.surface.fill((0, 0, 0, 0))
+        camera.surface.fblits(
+            [(self.original_surface, r.move(self.rect.x-camera.rect.x,self.rect.y-camera.rect.y)) for r in self._get_mosaic_rect_list()]
         )
-        # pygame.draw.rect(camera.surface,"green",next(self._get_mosaic_rect_list()).move(*self.rect.topleft),1)
-        camera.surface.blit(self.surface, camera.world_to_screen(self.rect))
-        return 1
+        # camera.surface.blit(self.surface, camera.world_to_screen(self.rect))
+        return

batFramework/stateMachine.py

@@ -7,11 +7,11 @@ class StateMachine: ...
 class State:
     def __init__(self, name: str) -> None:
         self.name = name
-        self.parent_entity: bf.Entity | bf.AnimatedSprite = None
+        self.parent: bf.Entity | bf.AnimatedSprite = None
         self.state_machine: StateMachine = None
 
-    def set_parent_entity(self, parent_entity: bf.Entity | bf.AnimatedSprite):
-        self.parent_entity = parent_entity
+    def set_parent(self, parent: bf.Entity | bf.AnimatedSprite):
+        self.parent = parent
 
     def set_stateMachine(self, stateMachine):
         self.state_machine = stateMachine
@@ -27,16 +27,19 @@ class State:
 
 
 class StateMachine:
-    def __init__(self, parent_entity) -> None:
+    def __init__(self, parent) -> None:
         self.states: dict[str, State] = {}
-        self.parent_entity = parent_entity
+        self.parent = parent
         self.current_state = None
 
     def add_state(self, state: State):
         self.states[state.name] = state
-        state.set_parent_entity(self.parent_entity)
+        state.set_parent(self.parent)
         state.set_stateMachine(self)
 
+    def remove_state(self,state_name: str):
+        self.states.pop(state_name,default=None)
+
     def set_state(self, state_name: str):
         if state_name in self.states:
             if self.current_state:

batFramework/templates/__init__.py

@@ -0,0 +1,2 @@
+from .character import *
+from .states import *

batFramework/templates/character.py

@@ -0,0 +1,44 @@
+import batFramework as bf
+import pygame
+from .states import *
+
+class Platform2DCharacter(bf.Character):
+    def __init__(self):
+        super().__init__()
+        self.actions = bf.ActionContainer(
+            *bf.DirectionalKeyControls(),
+            bf.Action("jump").add_key_control(pygame.K_SPACE).set_holding()
+        )
+        self.on_ground : bool = False
+        self.max_jumps = 2
+        self.jump_counter = 0
+        self.jump_force = 150
+        self.speed = 100
+        self.acceleration = 30
+        self.friction = 0.7
+        self.gravity = 300
+        self.terminal_velocity = 1000
+        self.state_machine.set_state("idle")
+        
+
+    def do_setup_animations(self):
+        self.add_animation(bf.Animation("idle"))
+        self.add_animation(bf.Animation("run"))
+        self.add_animation(bf.Animation("jump"))
+        self.add_animation(bf.Animation("fall"))
+
+
+    def do_setup_states(self):
+        self.state_machine.add_state(Platform2DIdle())
+        self.state_machine.add_state(Platform2DRun())
+        self.state_machine.add_state(Platform2DJump())
+        self.state_machine.add_state(Platform2DFall())
+
+
+
+    def do_reset_actions(self) -> None:
+        self.actions.reset()
+
+    def do_process_actions(self, event: pygame.Event) -> None:
+        self.actions.process_event(event)
+    

batFramework/templates/states.py

@@ -0,0 +1,166 @@
+import batFramework as bf
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .character import Platform2DCharacter
+
+
+class CharacterState(bf.State):
+    def set_parent(self, parent):
+        """Initialize the parent character."""
+        res = super().set_parent(parent)
+        if res:
+            self.parent: Platform2DCharacter = parent
+        return res
+
+    def on_enter(self):
+        """Handle state entry."""
+        self.parent.set_animation(self.name)
+
+    def handle_input(self):
+        """Process input and update movement direction."""
+        if self.parent.actions.is_active("right"):
+            self._apply_horizontal_input(self.parent.acceleration, self.parent.speed)
+        if self.parent.actions.is_active("left"):
+            self._apply_horizontal_input(-self.parent.acceleration, -self.parent.speed)
+
+        if self.parent.velocity.x > 0:
+            self.parent.set_flipX(False)
+        elif self.parent.velocity.x < 0:
+            self.parent.set_flipX(True)
+
+
+    def _apply_horizontal_input(self, acceleration, limit):
+        """Apply input acceleration and enforce speed limit."""
+
+        self.parent.velocity.x += acceleration
+        if abs(self.parent.velocity.x) > abs(limit):
+            self.parent.velocity.x = limit
+
+    def apply_friction(self):
+        """Apply friction to horizontal velocity."""
+        if (self.parent.actions.is_active("right") or self.parent.actions.is_active("left")):
+            return
+        
+        if abs(self.parent.velocity.x) < 0.01:  # Threshold for negligible velocity
+            self.parent.velocity.x = 0
+        else:
+            self.parent.velocity.x *= self.parent.friction
+
+    def apply_gravity(self, dt):
+        """Apply gravity to vertical velocity."""
+        self.parent.velocity.y += self.parent.gravity * dt
+        self.parent.velocity.y = min(self.parent.velocity.y, self.parent.terminal_velocity)
+
+    def move_character(self, dt):
+        """Move the character based on velocity."""
+        self.parent.rect.x += self.parent.velocity.x * dt
+        self.parent.rect.y += self.parent.velocity.y * dt
+
+    def update(self, dt):
+        """Update the character state."""
+        self.handle_input()
+        self.apply_physics(dt)
+        self.handle_collision()
+
+    def apply_physics(self, dt):
+        """Apply all physics effects."""
+        self.apply_friction()
+        self.move_character(dt)
+        if self.parent.on_ground:
+            self.parent.velocity.y = 0  # Stop downward movement on ground
+
+    def handle_collision(self):
+        """Placeholder for collision detection and resolution."""
+        pass  # Future collision code goes here
+
+
+class Platform2DIdle(CharacterState):
+    def __init__(self) -> None:
+        super().__init__("idle")
+
+    def on_enter(self):
+        self.parent.jump_counter = 0
+        super().on_enter()
+
+    def update(self, dt):
+        super().update(dt)
+        
+        if not self.parent.on_ground:
+            self.parent.set_state("fall")
+        elif self.parent.velocity.x != 0:
+            self.parent.set_state("run")
+        elif self.parent.actions.is_active("jump"):
+            self.parent.set_state("jump")
+
+
+class Platform2DRun(CharacterState):
+    def __init__(self) -> None:
+        super().__init__("run")
+
+
+    def on_enter(self):
+        self.parent.jump_counter = 0
+        super().on_enter()
+
+    def update(self, dt):
+        super().update(dt)
+
+        if self.parent.velocity.x :
+            if (self.parent.actions.is_active("right") or self.parent.actions.is_active("left")):
+                if self.parent.get_current_animation().name != "run" : self.parent.set_animation("run")
+            else:
+                if self.parent.get_current_animation().name != "idle" : self.parent.set_animation("idle")
+
+        if self.parent.actions.is_active("jump"):
+            self.parent.set_state("jump")
+        elif self.parent.velocity.x == 0:
+            if not (self.parent.actions.is_active("right") or self.parent.actions.is_active("left")):
+                self.parent.set_state("idle")
+        elif not self.parent.on_ground:
+            self.parent.set_state("fall")
+
+ 
+
+
+class Platform2DJump(CharacterState):
+    def __init__(self) -> None:
+        super().__init__("jump")
+
+    def on_enter(self):
+        super().on_enter()
+        self.parent.on_ground = False
+        self.parent.velocity.y = -self.parent.jump_force
+        self.parent.jump_counter += 1
+
+    def update(self, dt):
+        super().update(dt)
+        self.apply_gravity(dt)
+
+
+        if self.parent.jump_counter < self.parent.max_jumps:
+            if  self.parent.actions.is_active("jump") and (self.parent.velocity.y//10)*10 == 0:
+                self.parent.set_state("jump")
+                return
+
+
+        if self.parent.velocity.y > 0:
+            self.parent.set_state("fall")
+
+
+class Platform2DFall(CharacterState):
+    def __init__(self) -> None:
+        super().__init__("fall")
+
+    def update(self, dt):
+        super().update(dt)
+        self.apply_gravity(dt)
+
+        if self.parent.on_ground:
+            if abs(self.parent.velocity.x) > 0.01:
+                self.parent.set_state("run")
+            else:
+                self.parent.set_state("idle")
+
+        if self.parent.actions.is_active("jump") and self.parent.jump_counter < self.parent.max_jumps:
+            self.parent.set_state("jump")

batFramework/time.py

@@ -2,13 +2,21 @@ import batFramework as bf
 from typing import Self
 
 
+from typing import Callable, Union, Self
+
+
 class Timer:
     _count: int = 0
+    _available_ids: set[int] = set()
 
-    def __init__(self, duration: float | int, end_callback, loop: bool = False) -> None:
-        self.name: int = Timer._count
-        Timer._count += 1
+    def __init__(self, duration: Union[float, int], end_callback: Callable, loop: bool = False, register: str = "global") -> None:
+        if Timer._available_ids:
+            self.uid = Timer._available_ids.pop()
+        else:
+            self.uid = Timer._count
+            Timer._count += 1
 
+        self.register = register
         self.duration: int | float = duration
         self.end_callback = end_callback
 
@@ -18,8 +26,11 @@ class Timer:
         self.is_paused: bool = False
         self.do_delete: bool = False
 
-    def __repr__(self) -> str:
-        return f"Timer ({self.name}) {self.elapsed_time}/{self.duration} | {'loop ' if self.is_looping else ''} {'(D) ' if self.do_delete else ''}"
+    def __bool__(self)->bool:
+        return self.elapsed_time==-1 or 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 ''}"
 
     def stop(self) -> Self:
         self.elapsed_time = -1
@@ -30,7 +41,7 @@ class Timer:
     def start(self, force: bool = False) -> Self:
         if self.elapsed_time != -1 and not force:
             return self
-        if not bf.TimeManager().add_timer(self):
+        if not bf.TimeManager().add_timer(self,self.register):
             return self
         self.elapsed_time = 0
         self.is_paused = False
@@ -79,36 +90,42 @@ class Timer:
     def should_delete(self) -> bool:
         return self.is_over or self.do_delete
 
+    def _release_id(self):
+        Timer._available_ids.add(self.uid)
 
-class TimerRegister:
-    def __init__(self, active=True):
-        self.active = active
-        self.timers: dict[int | str, Timer] = {}
-
-    def __iter__(self):
-        return iter(self.timers.values())
-
-    def add_timer(self, timer: Timer):
-        self.timers[timer.name] = timer
-
-    def update(self, dt):
-        expired_timers = []
-        for timer in list(self.timers.values()):
-            if not timer.is_paused:
-                timer.update(dt)
-            if timer.should_delete():
-                expired_timers.append(timer.name)
-        for name in expired_timers:
-            del self.timers[name]
 
+class SceneTimer(Timer):
+    def __init__(self, duration: float | int, end_callback, loop: bool = False, scene_name:str = "global") -> None:
+        super().__init__(duration, end_callback, loop, scene_name)
 
 class TimeManager(metaclass=bf.Singleton):
+    class TimerRegister:
+        def __init__(self, active=True):
+            self.active = active
+            self.timers: dict[int | str, Timer] = {}
+
+        def __iter__(self):
+            return iter(self.timers.values())
+
+        def add_timer(self, timer: Timer):
+            self.timers[timer.uid] = timer
+
+        def update(self, dt):
+            expired_timers = []
+            for timer in list(self.timers.values()):
+                if not timer.is_paused:
+                    timer.update(dt)
+                if timer.should_delete():
+                    expired_timers.append(timer.uid)
+            for uid in expired_timers:
+                del self.timers[uid]
+
     def __init__(self):
-        self.registers = {"global": TimerRegister()}
+        self.registers = {"global": TimeManager.TimerRegister()}
 
     def add_register(self, name, active=True):
         if name not in self.registers:
-            self.registers[name] = TimerRegister(active)
+            self.registers[name] = TimeManager.TimerRegister(active)
 
     def add_timer(self, timer, register="global") -> bool:
         if register in self.registers:
@@ -133,3 +150,12 @@ class TimeManager(metaclass=bf.Singleton):
 
     def deactivate_register(self, name):
         self.activate_register(name, active=False)
+
+    def __str__(self)->str:
+        res = "" 
+        for name,reg in self.registers.items():
+            if not reg.timers:continue
+            res +=name+"\n"
+            for t in reg.timers.values():
+                res +="\t"+str(t)+"\n"
+        return res

batFramework/transition.py

@@ -87,10 +87,10 @@ class Transition:
 class FadeColor(Transition):
     def __init__(
         self,
-        color: tuple | str,
+        color: tuple,
         middle_duration: float,
-        first_duration: float = None,
-        second_duration: float = None,
+        first_duration: float | None = None,
+        second_duration: float | None = None,
         easing_function: bf.easing = bf.easing.LINEAR,
     ) -> None:
         super().__init__(0, easing_function)
@@ -98,16 +98,25 @@ class FadeColor(Transition):
             first_duration = middle_duration
         if second_duration is None:
             second_duration = middle_duration
-        self.index = 0
+
         self.first = Fade(first_duration)
+        self.second = Fade(second_duration)
         self.color = color
-        self.second = Fade(second_duration).set_end_callback(
-            lambda: self.next_step(self.end)
-        )
-        self.timer = bf.Timer(
-            middle_duration, lambda: self.next_step(self.second.start)
-        )
-        self.first.set_end_callback(lambda: self.next_step(self.timer.start))
+        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=None) -> None:
         self.index += 1
@@ -125,6 +134,7 @@ class FadeColor(Transition):
     def start(self):
         if self.start_callback:
             self.start_callback()
+
         self.color_surf = pygame.Surface(self.source.get_size())
         self.color_surf.fill(self.color)
 
@@ -141,7 +151,7 @@ class FadeColor(Transition):
             self.second.draw(surface)
 
     def skip(self, no_callback: bool = False):
-        if (no_callback == False) and self.end_callback:
+        if not no_callback and self.end_callback:
             self.end_callback()
 
         self.first.controller.stop()
@@ -149,6 +159,7 @@ class FadeColor(Transition):
         self.second.controller.stop()
 
 
+
 class Fade(Transition):
     def end(self):
         self.dest.set_alpha(255)
@@ -213,3 +224,5 @@ class CircleIn(Transition):
         )
         mask = pygame.mask.from_surface(self.circle_surf)
         mask.to_surface(surface=surface, setsurface=self.source, unsetsurface=self.dest)
+
+

batFramework/triggerZone.py

@@ -4,7 +4,7 @@ import batFramework as bf
 class TriggerZone(bf.Entity):
     def __init__(self, size, trigger, callback, active=True) -> None:
         super().__init__(size, True)
-        self.set_debug_color(bf.color.RIVER_BLUE)
+        self.set_debug_color(bf.color.RED)
         self.active = active
         self.callback = callback
         self.trigger = trigger

batFramework/utils.py

@@ -5,6 +5,11 @@ import batFramework as bf
 import json
 from .enums import *
 import re
+from typing import Callable, TYPE_CHECKING, Any
+from functools import cache
+if TYPE_CHECKING:
+    from .object import Object
+    from .entity import Entity
 
 
 class Singleton(type):
@@ -27,8 +32,6 @@ class Utils:
         with their tuple coordinates as keys.
         Exemple : '(0,0) : Surface'
         """
-        if surface is None:
-            return None
         width, height = surface.get_size()
         res = {}
         for iy, y in enumerate(range(0, height, split_size[1])):
@@ -57,3 +60,90 @@ class Utils:
             return pattern.sub("", s)
 
         return filter_function
+
+
+    @staticmethod
+    @cache
+    def create_spotlight(inside_color, outside_color, radius, radius_stop=None, dest_surf=None,size=None):
+        """
+        Draws a circle spotlight centered on a surface
+        inner color on the center
+        gradient towards outside color from radius to radius stop
+        surface background is made transparent
+        if des_surf is None:
+            if size is None :  size is radius_stop*radius_stop
+            returns the newly created surface of size 'size' with the spotlight drawn
+
+        """
+        if radius_stop is None:
+            radius_stop = radius
+        diameter = radius_stop * 2
+
+        if dest_surf is None:
+            if size is None:
+                size = (diameter,diameter)
+            dest_surf = pygame.Surface(size, pygame.SRCALPHA)
+        
+        dest_surf.fill((0,0,0,0))
+
+
+        center = dest_surf.get_rect().center
+
+        if radius_stop != radius:
+            for r in range(radius_stop, radius - 1, -1):
+                color = [
+                    inside_color[i] + (outside_color[i] - inside_color[i]) * (r - radius) / (radius_stop - radius)
+                    for i in range(3)
+                ] + [255]  # Preserve the alpha channel as fully opaque
+                pygame.draw.circle(dest_surf, color, center, r)
+        else:
+            pygame.draw.circle(dest_surf, inside_color, center, radius)
+
+        return dest_surf
+
+    @staticmethod
+    def draw_spotlight(dest_surf:pygame.Surface,inside_color,outside_color,radius,radius_stop=None,center=None):
+        if radius_stop is None:
+            radius_stop = radius
+        center = dest_surf.get_rect().center if center is None else center
+        if radius_stop != radius:
+            for r in range(radius_stop, radius - 1, -1):
+                color = [
+                    inside_color[i] + (outside_color[i] - inside_color[i]) * (r - radius) / (radius_stop - radius)
+                    for i in range(3)
+                ] + [255]
+                pygame.draw.circle(dest_surf, color, center, r)
+        else:
+            pygame.draw.circle(dest_surf, inside_color, center, radius)
+
+    @staticmethod
+    def animate_move(entity:"Object", start_pos : tuple[float,float], end_pos:tuple[float,float])->Callable[[float],None]:
+        def func(x):
+            entity.set_center(start_pos[0]+(end_pos[0]-start_pos[0])*x,start_pos[1]+(end_pos[1]-start_pos[1])*x)
+        return func
+    
+    def animate_move_to(entity: "Object", end_pos: tuple[float, float]) -> Callable[[float], None]:
+        # Start position will be captured once when the animation starts
+        start_pos = [None]
+
+        def update_position(progression: float):
+            if start_pos[0] is None:
+                start_pos[0] = entity.rect.center  # Capture the start position at the start of the animation
+
+            # Calculate new position based on progression
+            new_x = start_pos[0][0] + (end_pos[0] - start_pos[0][0]) * progression
+            new_y = start_pos[0][1] + (end_pos[1] - start_pos[0][1]) * progression
+
+            # Set the entity's new position
+            entity.set_center(new_x, new_y)
+
+        return update_position
+
+    @staticmethod
+    def animate_alpha(entity:"Entity", start : int, end:int)->Callable[[float],None]:
+        def func(x):
+            entity.set_alpha(int(pygame.math.clamp(start+(end-start)*x,0,255)))
+        return func
+    
+
+

{batframework-1.0.8a3.dist-info → batframework-1.0.8a6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: batframework
-Version: 1.0.8a3
+Version: 1.0.8a6
 Summary: Pygame framework for making games easier.
 Author-email: Turan Baturay <baturayturan@gmail.com>
 Project-URL: Homepage, https://github.com/TuranBaturay/batFramework
@@ -12,9 +12,9 @@ Description-Content-Type: text/markdown
 License-File: LICENCE
 Requires-Dist: pygame-ce
 
-# batFramework & gamejam Project
+# batFramework
 
-Welcome to the `batFramework` and the accompanying `gamejam` project. This README provides an overview of both the game framework and the specific game project developed using the framework.
+Welcome to the `batFramework`. This README provides an overview of the game framework.
 
 ## batFramework
 
@@ -38,18 +38,6 @@ The `batFramework` is a Python game development framework based on pygame, desig
 
 For more detailed information on how to use the framework, refer to the documentation (if available) or explore the source code in the `batFramework` directory.
 
-## gamejam Project
 
-The `gamejam` project is a specific game developed using the `batFramework`. It serves as an example of how the framework can be used to create a game from scratch.
-
-### Play the gamejam Project
-
-1. Install Python (version 3.10 or higher) and the latest stable version of pygame-ce.
-2. Clone or download this repository.
-3. Navigate to the `gamejam` directory.
-4. Run the game by executing the main script (e.g., `python main.py`).
-5. Play the game and have fun!
-
-Feel free to explore the code in the `gamejam` directory to see how the `batFramework` is utilized to create the game. You can modify, extend, or use the project as a starting point for your own games.