batframework 1.0.9a7__py3-none-any.whl → 1.0.9a9__py3-none-any.whl

batFramework/sceneLayer.py

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

@@ -8,9 +8,9 @@ def swap(lst, index1, index2):
 
 class SceneManager:
     def __init__(self) -> None:
-        self.scenes: list[bf.Scene] = []
+        self.scenes: list[bf.BaseScene] = []
         self.shared_events = {pygame.WINDOWRESIZED}
-        self.current_transitions: dict[str, bf.transition.Transition] = {}
+        self.current_transition : tuple[str,bf.transition.Transition,int] | None= None
 
     def init_scenes(self, *initial_scenes:bf.Scene):
         for index, s in enumerate(initial_scenes):
@@ -56,7 +56,7 @@ class SceneManager:
         print("\n" + "=" * 50)
         print(" DEBUGGING STATUS".center(50))
         print("=" * 50)
-        print(f"[Debugging Mode] = {self.debug_mode}")
+        print(f"[Debugging Mode] = {bf.ResourceManager().get_sharedVar("debug_mode")}")
 
         # Print shared variables
         print("\n" + "=" * 50)
@@ -86,7 +86,7 @@ class SceneManager:
         if scene in self.scenes and not self.has_scene(scene.name):
             return
         scene.set_manager(self)
-        scene.do_when_added()
+        scene.when_added()
         self.scenes.insert(0, scene)
 
     def remove_scene(self, name: str):
@@ -110,36 +110,34 @@ class SceneManager:
     def transition_to_scene(
         self,
         scene_name: str,
-        transition: bf.transition.Transition = bf.transition.Fade(0.1),
+        transition: bf.transition.Transition = None,
         index: int = 0,
     ):
-        target_scene = self.get_scene(scene_name)
-        if not target_scene:
+        if transition is None:
+            transition = bf.transition.Fade(0.1)
+        if not (target_scene := self.get_scene(scene_name)):
             print(f"Scene '{scene_name}' does not exist")
             return
-        if len(self.scenes) == 0 or index >= len(self.scenes) or index < 0:
-            return
+        if not (source_scene := self.get_scene_at(index)):
+            print(f"No scene exists at index {index}.")
+            return       
+        
         source_surface = bf.const.SCREEN.copy()
         dest_surface = bf.const.SCREEN.copy()
 
-        # self.draw(source_surface)
-        target_scene.draw(dest_surface)
-        target_scene.do_on_enter_early()
-        self.get_scene_at(index).do_on_exit_early()
-        self.current_transitions = {"scene_name": scene_name, "transition": transition}
-        transition.set_start_callback(lambda: self._start_transition(target_scene))
-        transition.set_end_callback(lambda: self._end_transition(scene_name, index))
+        target_scene.draw(dest_surface) # draw at least once to ensure smooth transition
+        target_scene.set_active(True)
+        target_scene.set_visible(True)
+
+        target_scene.do_on_enter_early() 
+        source_scene.do_on_exit_early()
+
+        self.current_transition :tuple[str,bf.transition.Transition]=(scene_name,transition,index)
         transition.set_source(source_surface)
         transition.set_dest(dest_surface)
         transition.start()
 
-    def _start_transition(self, target_scene: bf.Scene):
-        target_scene.set_active(True)
-        target_scene.set_visible(True)
 
-    def _end_transition(self, scene_name, index):
-        self.set_scene(scene_name, index, True)
-        self.current_transitions.clear()
 
     def set_scene(self, scene_name, index=0, ignore_early: bool = False):
         target_scene = self.get_scene(scene_name)
@@ -171,9 +169,6 @@ class SceneManager:
 
     def process_event(self, event: pygame.Event):
 
-        if self.current_transitions and event in bf.enums.playerInput:
-            return
-
         if event.type in self.shared_events:
             [s.process_event(event) for s in self.scenes]
         else:
@@ -182,21 +177,21 @@ class SceneManager:
     def update(self, dt: float) -> None:
         for scene in self.active_scenes:
             scene.update(dt)
+        if self.current_transition and self.current_transition[1].is_over:
+            self.set_scene(self.current_transition[0],self.current_transition[2],True)
+            self.current_transition = None
         self.do_update(dt)
 
     def do_update(self, dt: float):
         pass
 
-    def draw(self, surface) -> None:
+    def draw(self, surface:pygame.Surface) -> None:
         for scene in self.visible_scenes:
             scene.draw(surface)
-        if self.current_transitions:
-            self._draw_transition(surface)
-
-    def _draw_transition(self, surface):
-        self.current_transitions["transition"].set_source(surface)
-        tmp = bf.const.SCREEN.copy()
-        self.get_scene(self.current_transitions["scene_name"]).draw(tmp)
-        self.current_transitions["transition"].set_dest(tmp)
-        self.current_transitions["transition"].draw(surface)
-        return
+        if self.current_transition is not None:
+            self.current_transition[1].set_source(surface)
+            tmp = surface.copy()
+            self.get_scene(self.current_transition[0]).draw(tmp)
+            self.current_transition[1].set_dest(tmp)
+            self.current_transition[1].draw(surface)
+

batFramework/scrollingSprite.py

@@ -66,7 +66,7 @@ class ScrollingSprite(bf.Sprite):
         self.rect = self.surface.get_frect(topleft=self.rect.topleft)
         return self
 
-    def _get_mosaic_rect_list(self) -> Iterator[pygame.Rect]:
+    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)
@@ -90,7 +90,12 @@ class ScrollingSprite(bf.Sprite):
         while x < end_x:
             y = y_position
             while y < end_y:
-                yield pygame.Rect(x, y, self.original_width, self.original_height)
+                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
@@ -104,7 +109,7 @@ class ScrollingSprite(bf.Sprite):
             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()]
+            [(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

@@ -6,8 +6,8 @@ from typing import Self
 class Sprite(bf.Drawable):
     def __init__(
         self,
-        size: None | tuple[int, int] = None,
         path=None,
+        size: None | tuple[int, int] = None,
         convert_alpha: bool = True,
     ):
         self.original_surface: pygame.Surface = None

batFramework/templates/__init__.py

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

batFramework/templates/controller.py

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

@@ -1,12 +1,11 @@
 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: Union[float, int], end_callback: Callable[[],Any], loop: bool = False, register: str = "global") -> None:
+    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:
@@ -14,85 +13,133 @@ class Timer:
             Timer._count += 1
 
         self.register = register
-        self.duration: int | float = duration
+        self.duration: float = duration
         self.end_callback = end_callback
 
-        self.elapsed_time: float = -1
+        self.elapsed_time: float = 0
         self.is_over: bool = False
-        self.is_looping: bool = loop
+        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 or self.is_over
+    def __bool__(self) -> bool:
+        return self.elapsed_time != -1 and 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 ''}"
+        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:
-        self.elapsed_time = -1
-        self.is_over = False
+        """
+        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:
-        if self.elapsed_time != -1 and not force:
+        """
+        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):
+        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:
-        return self.elapsed_time != -1
+        """
+        Returns True if the timer has started.
+        """
+        return not self.is_stopped
 
     def get_progression(self) -> float:
-        if self.elapsed_time < 0:
+        """
+        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.elapsed_time < 0 or self.is_paused or self.is_over:
+        if self.is_stopped 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):
+        """
+        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()
-        self.elapsed_time = -1
-        self.is_over = True
-        if self.is_looping:
+
+        # 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):
-    def __init__(self, duration: float | int, end_callback, loop: bool = False, scene_name:str = "global") -> None:
+    """
+    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):
@@ -125,6 +172,13 @@ class TimeManager(metaclass=bf.Singleton):
         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)
@@ -136,7 +190,7 @@ class TimeManager(metaclass=bf.Singleton):
         return [t for t in self.registers.values() if t.active]
 
     def update(self, dt):
-        for register_name, register in self.registers.items():
+        for register in self.registers.values():
             if register.active:
                 register.update(dt)