batframework 1.0.9a10__py3-none-any.whl → 1.1.0__py3-none-any.whl

batFramework/sceneLayer.py

@@ -1,138 +0,0 @@
-from __future__ import annotations
-import batFramework as bf
-import pygame
-from .entity import Entity
-from .drawable import Drawable
-
-from typing import TYPE_CHECKING, Any
-if TYPE_CHECKING:
-    from .baseScene import BaseScene 
-
-class SceneLayer:
-    """
-    A scene layer is a 'dimension' bound to a scene
-    Each layer contains its own entities and camera
-    One common use would be to separate GUI and game into two separate layers
-    """
-    def __init__(self,name:str,convert_alpha:bool = False):
-        self.scene = None
-        self.name = name
-        self.entities : dict[int,Entity] = {}
-        self.entities_to_add : set[Entity]= set()
-        self.entities_to_remove : set[Entity]= set()
-        self.draw_order : list[int] = []
-        self.camera = bf.Camera(convert_alpha=convert_alpha)
-
-    def set_clear_color(self,color):
-        self.camera.set_clear_color(color)
-
-    def set_scene(self, scene:BaseScene):
-        self.scene = scene
-
-    def add(self,*entities:Entity):
-        for e in entities:
-            if e.uid not in self.entities and e not in self.entities_to_add:
-                self.entities_to_add.add(e)
-
-
-    def get_by_tags(self,*tags)->list[Entity]:
-        return [v for v in self.entities.values() if v.has_tags(*tags) ]
-
-    def get_by_uid(self,uid:int)->Entity|None:
-        return self.entities.get(uid,None)
-
-    def remove(self,*entities:Entity):
-        for e in entities:
-            if e.uid in self.entities and e not in self.entities_to_remove:
-                self.entities_to_remove.add(e)
-
-    def process_event(self,event:pygame.Event):
-        if event.type == pygame.VIDEORESIZE and not pygame.SCALED & bf.const.FLAGS:
-            self.camera.set_size(bf.const.RESOLUTION)
-
-        for e in self.entities.values():
-            e.process_event(event)
-            if event.consumed : return
-
-    def update(self, dt):
-        # Update all entities
-        for e in self.entities.values():
-            e.update(dt)
-
-        self.flush_entity_changes()
-
-        # Update the camera
-        self.camera.update(dt)
-
-    def flush_entity_changes(self):
-        """
-        Synchronizes entity changes by removing entities marked for removal,
-        adding new entities, and updating the draw order if necessary.
-        """
-
-
-        # Remove entities marked for removal
-        for e in self.entities_to_remove:
-            if e.uid in self.entities.keys():
-                e.set_parent_scene(None)
-                self.entities.pop(e.uid)
-        self.entities_to_remove.clear()
-
-        # Add new entities
-        reorder = False
-        for e in self.entities_to_add:
-            self.entities[e.uid] = e
-            e.set_parent_layer(self)
-            e.set_parent_scene(self.scene)
-            if not reorder and isinstance(e, Drawable):
-                reorder = True
-        self.entities_to_add.clear()
-
-        # Reorder draw order if necessary
-        if reorder:
-            self.update_draw_order()
-
-    def clear(self):
-        """
-        Clear the camera surface
-        """
-        self.camera.clear()
-
-    def draw(self, surface: pygame.Surface):
-        self.camera.clear()
-        debugMode = bf.ResourceManager().get_sharedVar("debug_mode")
-        # Draw entities in the correct order
-        for uid in self.draw_order:
-            if uid in self.entities and not self.entities[uid].drawn_by_group:  # Ensure the entity still exists
-                self.entities[uid].draw(self.camera)
-
-        # Draw debug outlines if in debug mode
-        if debugMode == bf.debugMode.OUTLINES:
-            [self.debug_entity(uid) for uid in self.draw_order if uid in self.entities]
-
-        # Blit the camera surface onto the provided surface
-        # surface.blit(self.camera.surface, (0, 0))
-        self.camera.draw(surface)
-
-    def update_draw_order(self):
-        self.draw_order = sorted(
-            (k for k,v in self.entities.items() if isinstance(v,Drawable) and not v.drawn_by_group),
-            key= lambda uid : self.entities[uid].render_order
-        )
-
-    def debug_entity(self, uid: int):
-        entity = self.entities[uid]
-        def draw_rect(data):
-            if data is None:
-                return
-            if isinstance(data, pygame.FRect) or isinstance(data, pygame.Rect):
-                rect = data
-                color = entity.debug_color
-            else:
-                rect = data[0]
-                color = data[1]
-            if self.camera.intersects(rect):
-                pygame.draw.rect(self.camera.surface, color, self.camera.world_to_screen(rect), 1)
-
-        for data in entity.get_debug_outlines():
-            draw_rect(data)

batFramework/scrollingSprite.py

@@ -1,115 +0,0 @@
-from typing import Self, Iterator
-from pygame.math import Vector2
-import batFramework as bf
-import pygame
-
-
-class ScrollingSprite(bf.Sprite):
-    def __init__(
-        self,
-        data: pygame.Surface | str,
-        size: None | tuple[int, int] = None,
-        convert_alpha: bool = True,
-    ):
-        self.scroll_value = Vector2(0, 0)
-        self.auto_scroll = Vector2(0, 0)
-
-        # Use integer values for the starting points, converted from floating point scroll values
-
-        super().__init__(size, data, convert_alpha)
-        if self.original_surface:
-            self.original_width, self.original_height = self.original_surface.get_size()
-
-
-    def get_debug_outlines(self):
-        yield from super().get_debug_outlines()
-        for r in self._get_mosaic_rect_list():
-            yield r.move(*self.rect.topleft)
-
-
-    def set_autoscroll(self, x: float, y: float) -> Self:
-        self.auto_scroll.update(x, y)
-        return self
-
-    def set_scroll(self, x: float = None, y: float = None) -> Self:
-        self.scroll_value.update(
-            x if x else self.scroll_value.x, y if y else self.scroll_value.y
-        )
-        return self
-
-    def scroll(self, x: float, y: float) -> Self:
-        self.scroll_value += x, y
-        return self
-
-    def update(self, dt: float) -> None:
-        if self.auto_scroll:
-            self.scroll(*self.auto_scroll * dt)
-        original_width, original_height = self.original_surface.get_size()
-
-        # Use integer values for the starting points, converted from floating point scroll values
-
-        if self.scroll_value.x > self.original_width:
-            self.scroll_value.x -= self.original_width
-        if self.scroll_value.y > self.original_height:
-            self.scroll_value.y -= self.original_height
-
-        super().update(dt)
-
-    def set_size(self, size: tuple[int | None, int | None]) -> Self:
-        size = list(size)
-        if size[0] is None:
-            size[0] = self.rect.w
-        if size[1] is None:
-            size[1] = self.rect.h
-
-        self.surface = pygame.Surface(size).convert_alpha()
-        self.rect = self.surface.get_frect(topleft=self.rect.topleft)
-        return self
-
-    def _get_mosaic_rect_list(self,camera:bf.Camera=None) -> Iterator[pygame.Rect]:
-        # Use integer values for the starting points, converted from floating point scroll values
-        start_x = int(self.scroll_value.x % self.original_width)
-        start_y = int(self.scroll_value.y % self.original_height)
-
-        # Adjust start_x and start_y to begin tiling off-screen to the top-left, covering all visible area
-        if start_x != 0:
-            start_x -= self.original_width
-        if start_y != 0:
-            start_y -= self.original_height
-
-        # Set the region in which to tile
-        end_x = self.rect.w
-        end_y = self.rect.h
-
-        # Starting y_position for the inner loop
-        y_position = start_y
-
-        # if self.rect.w-1 < self.scroll_value.x < self.rect.w+1 : print(self.scroll_value.x,int(self.scroll_value.x % self.rect.w),start_x,self.rect.w,original_width)
-        # Generate all necessary rectangles
-        x = start_x
-        while x < end_x:
-            y = y_position
-            while y < end_y:
-                r = pygame.Rect(x, y, self.original_width, self.original_height)
-                
-                if camera and camera.rect.colliderect((x+camera.rect.x,y+camera.rect.y,self.original_width,self.original_height)):
-                    yield r
-                else:
-                    yield r
-                y += self.original_height
-            x += self.original_width
-        return self
-
-    def draw(self, camera: bf.Camera) -> None:
-        if not (
-            self.visible
-            and (self.surface is not None)
-            and camera.rect.colliderect(self.rect)
-        ):
-            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(camera)]
-        )
-        # camera.surface.blit(self.surface, camera.world_to_screen(self.rect))
-        return

batFramework/sprite.py

@@ -1,51 +0,0 @@
-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

batFramework/templates/__init__.py

@@ -1 +0,0 @@
-from .controller import *

batFramework/templates/controller.py

@@ -1,97 +0,0 @@
-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/tileset.py

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

@@ -1,213 +0,0 @@
-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