batframework 1.0.8a8__py3-none-any.whl → 1.0.8a10__py3-none-any.whl

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/tileset.py

@@ -0,0 +1,46 @@
+import pygame
+from .resourceManager import ResourceManager
+import batFramework as bf
+
+
+class Tileset:
+    def __init__(self, source: pygame.Surface, tilesize: tuple[int, int]) -> None:
+        self.surface = source
+        self.tile_size = tilesize
+        self.tile_width = source.get_width() // tilesize[0]
+        self.tile_height = source.get_height() // tilesize[1]
+        # Create flipped versions of the tileset surface
+        self.flipped_surfaces = {
+            (False, False): self.surface,
+            (False, True): pygame.transform.flip(self.surface, False, True),
+            (True, False): pygame.transform.flip(self.surface, True, False),
+            (True, True): pygame.transform.flip(self.surface, True, True),
+        }
+
+        # Split each of the surfaces into tiles
+        self.tile_dict = {}
+        for flip_state, surf in self.flipped_surfaces.items():
+            tiles = bf.utils.split_surface(surf, self.tile_size)
+            for coord, tile in tiles.items():
+                if coord not in self.tile_dict:
+                    self.tile_dict[coord] = {}
+                self.tile_dict[coord][flip_state] = tile
+
+    def __str__(self) -> str:
+        num_tiles = 0
+        if self.tile_dict:
+            num_tiles = len(self.tile_dict.values())
+        return f"{num_tiles} tiles | Tile size : {self.tile_size}"
+
+    def get_tile(
+        self, x: int, y: int, flipX=False, flipY=False
+    ) -> pygame.Surface | None:
+        if flipX:
+            x = self.tile_width - 1 - x
+        if flipY:
+            y = self.tile_height - 1 - y
+        tile_data = self.tile_dict.get((x, y), None)
+        if tile_data is None:
+            return None
+
+        return tile_data.get((flipX, flipY), None)

batFramework/time.py

@@ -1,75 +1,162 @@
-import pygame
 import batFramework as bf
+from typing import Self
+
+
+from typing import Callable, Union, Self
+
 
 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
+    _count: int = 0
+    _available_ids: set[int] = set()
+
+    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
-        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
+        self.elapsed_time: float = -1
+        self.is_over: bool = False
+        self.is_looping: bool = loop
+        self.is_paused: bool = False
+        self.do_delete: bool = False
+
+    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
+        self.is_over = False
+        self.is_paused = False
+        return self
+
+    def start(self, force: bool = False) -> Self:
+        if self.elapsed_time != -1 and not force:
+            return self
+        if not bf.TimeManager().add_timer(self,self.register):
+            return self
+        self.elapsed_time = 0
+        self.is_paused = False
+        self.is_over = False
+        return self
+
+    def pause(self) -> Self:
+        self.is_paused = True
+        return self
+
+    def resume(self) -> Self:
+        self.is_paused = False
+        return self
+
+    def delete(self) -> Self:
+        self.do_delete = True
+        return self
+
+    def has_started(self) -> bool:
+        return self.elapsed_time != -1
+
+    def get_progression(self) -> float:
+        if self.elapsed_time < 0:
+            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:
+            return
+        self.elapsed_time += dt
+        # print("update :",self.elapsed_time,self.duration)
+        if self.get_progression() == 1:
+            self.end()
 
     def end(self):
-        self.elapsed_progress = 1
-        self.stopped = False
         if self.end_callback:
             self.end_callback()
+        self.elapsed_time = -1
+        self.is_over = True
+        if self.is_looping:
+            self.start()
+            return
+
+    def should_delete(self) -> bool:
+        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:
+        super().__init__(duration, end_callback, loop, scene_name)
 
-    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 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:
+                self.timers[uid]._release_id()
+                del self.timers[uid]
 
-class Time(metaclass=bf.Singleton):
     def __init__(self):
-        # Initialize the Time class with a dictionary of timers
-        self.timers = {}
+        self.registers = {"global": TimeManager.TimerRegister()}
+
+    def add_register(self, name, active=True):
+        if name not in self.registers:
+            self.registers[name] = TimeManager.TimerRegister(active)
+
+    def add_timer(self, timer, register="global") -> bool:
+        if register in self.registers:
+            self.registers[register].add_timer(timer)
+            return True
+        print(f"Register '{register}' does not exist.")
+        return False
+
+    def get_active_registers(self) -> list[TimerRegister]:
+        return [t for t in self.registers.values() if t.active]
 
-    def add_timer(self, timer):
-        # Add a timer to the dictionary
-        self.timers[timer.name] = timer
+    def update(self, dt):
+        for register_name, register in self.registers.items():
+            if register.active:
+                register.update(dt)
 
-    def update(self):
-        # Update all timers and remove completed ones
-        for timer in list(self.timers.values()):
-            timer.update()
+    def activate_register(self, name, active=True):
+        if name in self.registers:
+            self.registers[name].active = active
+        else:
+            print(f"Register '{name}' does not exist.")
 
-        to_remove = [name for name, timer in self.timers.items() if timer.ended()]
+    def deactivate_register(self, name):
+        self.activate_register(name, active=False)
 
-        for name in to_remove:
-            # print(self.timers.pop(name).name,"removed !")
-            self.timers.pop(name)
+    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