batframework 1.0.9a11__py3-none-any.whl → 1.0.9a12__py3-none-any.whl

batFramework/sprite.py

@@ -1,51 +1,46 @@
-import batFramework as bf
-import pygame
-from typing import Self
-
-
-class Sprite(bf.Drawable):
-    def __init__(
-        self,
-        path=None,
-        size: None | tuple[int, int] = None,
-        convert_alpha: bool = True,
-    ):
-        self.original_surface: pygame.Surface = None
-
-        super().__init__(convert_alpha=convert_alpha)
-        if path is not None:
-            self.from_path(path)
-        if size is not None and self.original_surface:
-            self.set_size(self.original_surface.get_size())
-
-    def set_size(self, size: tuple[float, float]) -> Self:
-        if size == self.rect.size:
-            return self
-        self.rect.size = size
-        self.surface = pygame.Surface(
-            (int(self.rect.w), int(self.rect.h)), self.surface_flags
-        )
-        if self.convert_alpha:
-            self.surface = self.surface.convert_alpha()
-        self.surface.fill((0, 0, 0, 0 if self.convert_alpha else 255))
-        self.surface.blit(
-            pygame.transform.scale(self.original_surface, self.rect.size), (0, 0)
-        )
-        return self
-
-    def from_path(self, path: str) -> Self:
-        tmp = bf.ResourceManager().get_image(path, self.convert_alpha)
-        if tmp is None:
-            return self
-        self.original_surface = tmp
-        size = self.original_surface.get_size()
-        self.set_size(size)
-        return self
-
-    def from_surface(self, surface: pygame.Surface) -> Self:
-        if surface is None:
-            return self
-        self.original_surface = surface
-        size = self.original_surface.get_size()
-        self.set_size(size)
-        return self
+import batFramework as bf
+import pygame
+from typing import Self
+
+
+class Sprite(bf.Drawable):
+    def __init__(
+        self,
+        path=None,
+        size: None | tuple[int, int] = None,
+        convert_alpha: bool = True,
+    ):
+        self.original_surface: pygame.Surface = None
+
+        super().__init__(convert_alpha=convert_alpha)
+        if path is not None:
+            self.from_path(path)
+        if size is not None and self.original_surface:
+            self.set_size(self.original_surface.get_size())
+
+    def set_size(self, size: tuple[float, float]) -> Self:
+        tmp = self.rect.size
+        super().set_size(size)
+        if self.rect.size == tmp:
+            return self
+        self.surface.blit(
+            pygame.transform.scale(self.original_surface, self.rect.size), (0, 0)
+        )
+        return self
+
+    def from_path(self, path: str) -> Self:
+        tmp = bf.ResourceManager().get_image(path, self.convert_alpha)
+        if tmp is None:
+            return self
+        self.original_surface = tmp
+        size = self.original_surface.get_size()
+        self.set_size(size)
+        return self
+
+    def from_surface(self, surface: pygame.Surface) -> Self:
+        if surface is None:
+            return self
+        self.original_surface = surface
+        size = self.original_surface.get_size()
+        self.set_size(size)
+        return self

batFramework/stateMachine.py

@@ -1,54 +1,49 @@
-import batFramework as bf
-
-
-class StateMachine: ...
-
-
-class State:
-    def __init__(self, name: str) -> None:
-        self.name = name
-        self.parent: bf.Entity | bf.AnimatedSprite = None
-        self.state_machine: StateMachine = None
-
-    def set_parent(self, parent: bf.Entity | bf.AnimatedSprite):
-        self.parent = parent
-
-    def set_stateMachine(self, stateMachine):
-        self.state_machine = stateMachine
-
-    def update(self, dt):
-        pass
-
-    def on_enter(self):
-        pass
-
-    def on_exit(self):
-        pass
-
-
-class StateMachine:
-    def __init__(self, parent) -> None:
-        self.states: dict[str, State] = {}
-        self.parent = parent
-        self.current_state = None
-
-    def add_state(self, state: State):
-        self.states[state.name] = state
-        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:
-                self.current_state.on_exit()
-            self.current_state = self.states[state_name]
-            self.current_state.on_enter()
-
-    def get_current_state(self) -> State:
-        return self.current_state
-
-    def update(self, dt):
-        self.current_state.update(dt)
+import batFramework as bf
+
+
+class State:
+    def __init__(self, name: str) -> None:
+        self.name = name
+        self.parent: bf.Entity = None
+        self.state_machine: StateMachine = None
+
+    def set_parent(self, parent: bf.Entity | bf.AnimatedSprite):
+        self.parent = parent
+
+    def set_stateMachine(self, stateMachine):
+        self.state_machine = stateMachine
+
+    def update(self, dt):
+        pass
+
+    def on_enter(self):
+        pass
+
+    def on_exit(self):
+        pass
+
+
+class StateMachine:
+    def __init__(self, parent) -> None:
+        self.states: dict[str, State] = {}
+        self.parent = parent
+        self.current_state = None
+
+    def add_state(self, *states: State):
+        for state in states :
+            self.states[state.name] = state
+            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:
+                self.current_state.on_exit()
+            self.current_state = self.states[state_name]
+            self.current_state.on_enter()
+
+    def update(self, dt):
+        self.current_state.update(dt)

batFramework/templates/__init__.py

@@ -1 +1,2 @@
-from .controller import *
+from .controller import *
+from .character import *

batFramework/templates/character.py

@@ -0,0 +1,15 @@
+from .stateMachine import AnimatedSprite,AnimatedStateMachine
+from .controller import PlatformController
+import batFramework as bf
+import pygame
+
+
+
+class PlatformCharacter(bf.AnimatedSprite,PlatformController):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.animachine = AnimatedStateMachine(self)
+        
+
+
+

batFramework/templates/controller.py

@@ -1,97 +1,158 @@
-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()
+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

@@ -1,46 +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)
+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)