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

batFramework/templates/controller.py

@@ -0,0 +1,158 @@
+import batFramework as bf
+import pygame
+from .stateMachine import *
+
+
+
+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.terminal_velocity = 1000
+        self.on_ground = False
+        self.friction = 0.7
+        
+    def reset_actions(self):
+        self.control.reset()
+
+    def 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)
+        if (not self.control.is_active("right")) and (not self.control.is_active("left")):
+            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.velocity.y > self.terminal_velocity:
+                self.velocity.y = self.terminal_velocity
+        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.y += self.velocity.y * dt
+        self.check_collision_y()
+        self.rect.x += self.velocity.x * dt
+        self.check_collision_x()
+
+
+
+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 reset_actions(self):
+        self.control.reset()
+
+    def 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()
+
+
+
+
+class CameraController(bf.Entity):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.origin = None  # Previous frame's world mouse pos
+        self.mouse_actions = bf.ActionContainer(
+            bf.Action("control").add_key_control(pygame.K_LCTRL).set_holding(),
+            bf.Action("drag").add_mouse_control(1).set_holding().set_consume_event(True),
+            bf.Action("zoom_in").add_mouse_control(4).set_consume_event(True),
+            bf.Action("zoom_out").add_mouse_control(5).set_consume_event(True),
+        )
+
+    def reset_actions(self):
+        self.mouse_actions.reset()
+
+    def process_actions(self, event):
+        self.mouse_actions.process_event(event)
+        if self.mouse_actions["drag"] and event.type == pygame.MOUSEMOTION:
+            event.consumed = True
+
+    def do_update(self, dt):
+        cam = self.parent_layer.camera
+        if self.mouse_actions["zoom_in"]:
+            if self.mouse_actions["control"]:
+                cam.rotate_by(10)
+            else:
+                cam.zoom(cam.zoom_factor * 1.1)
+
+        elif self.mouse_actions["zoom_out"]:
+            if self.mouse_actions["control"]:
+                cam.rotate_by(-10)
+            else:
+                cam.zoom(cam.zoom_factor / 1.1)
+
+        if self.mouse_actions["drag"]:
+            mouse_world = cam.get_mouse_pos()
+            cam_pos = cam.world_rect.topleft
+
+            if self.origin is None:
+                self.origin = (mouse_world[0] - cam_pos[0], mouse_world[1] - cam_pos[1])
+            else:
+                offset = (mouse_world[0] - cam_pos[0], mouse_world[1] - cam_pos[1])
+                dx = offset[0] - self.origin[0]
+                dy = offset[1] - self.origin[1]
+
+                cam.move_by(-dx, -dy)
+                self.origin = (mouse_world[0] - cam_pos[0], mouse_world[1] - cam_pos[1])
+
+
+        else:
+            self.origin = None

batFramework/templates/stateMachine.py

@@ -0,0 +1,39 @@
+import batFramework as bf
+import pygame
+from batFramework.stateMachine import State,StateMachine
+from ..animation import Animation
+from ..animatedSprite import AnimatedSprite
+
+class AnimatedState(State):
+
+    def __init__(self, animation:str):
+        super().__init__(animation)
+        self._transition : dict[str,str] = {}
+        self.animation = animation
+
+    def add_transition(self,dest:str,transition_animation:str):
+        self._transition[dest] = transition_animation
+
+
+class AnimatedStateMachine(StateMachine):
+    def __init__(self, parent:AnimatedSprite):
+        self.states: dict[str, AnimatedState] = {}
+        self.parent:AnimatedSprite = parent
+        self.current_state = None
+
+    def set_state(self, state_name: str,reset_counter:bool = True):
+
+        if state_name not in self.states:
+            return
+            
+        if self.current_state:
+            self.current_state.on_exit()
+        
+        if self.current_state and state_name in self.current_state._transition:
+            self.parent.set_animation(self.current_state._transition[state_name],reset_counter,0,self.states[state_name].animation)
+        else:
+            self.parent.set_animation(self.states[state_name].animation,reset_counter)
+
+        self.current_state = self.states[state_name]
+        self.current_state.on_enter()
+

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

@@ -0,0 +1,213 @@
+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: float, end_callback: Callable[[], Any], loop: int = 0, 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: float = duration
+        self.end_callback = end_callback
+
+        self.elapsed_time: float = 0
+        self.is_over: bool = False
+        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 and self.is_over
+
+    def __str__(self) -> str:
+        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:
+        """
+        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:
+        """
+        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):
+            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:
+        """
+        Returns True if the timer has started.
+        """
+        return not self.is_stopped
+
+    def get_progression(self) -> float:
+        """
+        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.is_stopped or self.is_paused or self.is_over:
+            return
+        self.elapsed_time += dt
+        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()
+
+        # 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):
+    """
+    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):
+    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]
+
+    def __init__(self):
+        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 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)
+            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 update(self, dt):
+        for register in self.registers.values():
+            if register.active:
+                register.update(dt)
+
+    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.")
+
+    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