batframework 1.0.8a3__py3-none-any.whl → 1.0.8a6__py3-none-any.whl

batFramework/gui/widget.py

@@ -35,6 +35,8 @@ class Widget(bf.Entity, metaclass=WidgetMeta):
         self.is_root: bool = False
         self.autoresize_w, self.autoresize_h = True, True
         self.__constraint_iteration = 0
+        self.__constraints_to_ignore = []
+        self.__constraints_capture = None
 
     def show(self) -> Self:
         self.visit(lambda w: w.set_visible(True))
@@ -110,7 +112,7 @@ class Widget(bf.Entity, metaclass=WidgetMeta):
         ]
         return self
 
-    def set_parent_scene(self, parent_scene: bf.Scene) -> Self:
+    def set_parent_scene(self, parent_scene: bf.Scene | None) -> Self:
         super().set_parent_scene(parent_scene)
         if parent_scene is None:
             bf.StyleManager().remove_widget(self)
@@ -122,8 +124,8 @@ class Widget(bf.Entity, metaclass=WidgetMeta):
     def set_parent(self, parent: "Widget") -> Self:
         if parent == self.parent:
             return self
-        if self.parent is not None:
-            self.parent.remove(self)
+        # if self.parent is not None and self.parent != parent:
+        #     self.parent.remove(self)
         self.parent = parent
         return self
 
@@ -188,47 +190,75 @@ class Widget(bf.Entity, metaclass=WidgetMeta):
         seen = set()
         result = []
         for c in self.constraints:
-            if c.name not in seen:
+            if not any(c == o for o in seen):
                 result.append(c)
                 seen.add(c.name)
         self.constraints = result
         self.constraints.sort(key=lambda c: c.priority)
         self.dirty_constraints = True
+        self.__constraint_to_ignore = []
+
+        return self
+
+
+    def remove_constraints(self, *names: str) -> Self:
+        for c in self.constraints:
+            if c.name in names:
+                c.on_removal(self)
+        self.constraints = [c for c in self.constraints if c.name not in names]
+        self.__constraint_to_ignore = []
         return self
 
     def resolve_constraints(self) -> None:
         if self.parent is None or not self.constraints:
             self.dirty_constraints = False
             return
-        all_good = False
-        constraint_iteration = 0
-        while not all_good:
-            for constraint in self.constraints:
-                if not constraint.evaluate(self.parent, self):
-                    constraint.apply(self.parent, self)
-                    # print(constraint.name,"Applied")
-            constraint_iteration += 1
-            if all(c.evaluate(self.parent, self) for c in self.constraints):
-                all_good = True
+
+        if not self.__constraint_iteration:
+            self.__constraints_capture = None
+        else:
+            capture = tuple([c.priority for c in self.constraints])
+            if capture != self.__constraints_capture:
+                self.__constraints_capture = capture
+                self.__constraint_to_ignore = []
+
+        constraints = self.constraints.copy()
+        # If all are resolved early exit
+        if all(c.evaluate(self.parent,self) for c in constraints if c not in self.__constraint_to_ignore):
+            self.dirty_constraints = False
+            return
+        
+        # # Here there might be a conflict between 2 or more constraints
+        # we have to determine which ones causes conflict and ignore the one with least priority
+
+        stop = False
+
+        while True:
+            stop = True
+            # first pass with 2 iterations to sort out the transformative constraints
+            for _ in range(2):
+                for c in constraints:
+                    if c in self.__constraints_to_ignore:continue
+                    if not c.evaluate(self.parent,self) :
+                        c.apply(self.parent,self)
+            # second pass where we check conflicts
+            for c in constraints:
+                if c in self.__constraints_to_ignore:
+                    continue
+                if not c.evaluate(self.parent,self):
+                    # first pass invalidated this constraint
+                    self.__constraints_to_ignore.append(c)
+                    stop = False
+                    break
+
+            if stop: 
                 break
-            elif self.__constraint_iteration > MAX_CONSTRAINTS:
-                print(
-                    self,
-                    "CONSTRAINTS ERROR",
-                    list(
-                        c.name
-                        for c in self.constraints
-                        if not c.evaluate(self.parent, self)
-                    ),
-                )
-                self.dirty_constraints = False
-                return
-        # print("DONE")
-        self.dirty_constraints = False
 
-    def remove_constraints(self, *names: str) -> Self:
-        self.constraints = [c for c in self.constraints if c.name not in names]
-        return self
+        if self.__constraints_to_ignore:
+            print("Constraints ignored : ",[str(c) for c in self.__constraints_to_ignore])
+        
+
+        self.dirty_constraints = False
 
     def has_constraint(self, name: str) -> bool:
         return any(c.name == name for c in self.constraints)
@@ -236,7 +266,9 @@ class Widget(bf.Entity, metaclass=WidgetMeta):
     def get_root(self) -> "Root":
         if self.is_root:
             return self
-        return self.parent.get_root()
+        if self.parent:
+            return self.parent.get_root()
+        return None
 
     def top_at(self, x: float | int, y: float | int) -> "None|Widget":
         if self.children:
@@ -251,6 +283,7 @@ class Widget(bf.Entity, metaclass=WidgetMeta):
         self.children.extend(children)
         i = len(self.children)
         for child in children:
+
             child.set_render_order(i).set_parent(self).set_parent_scene(
                 self.parent_scene
             )
@@ -262,8 +295,8 @@ class Widget(bf.Entity, metaclass=WidgetMeta):
     def remove(self, *children: "Widget") -> Self:
         for child in self.children:
             if child in children:
-                self.children.remove(child)
                 child.set_parent(None).set_parent_scene(None)
+                self.children.remove(child)
         if self.parent:
             self.parent.do_sort_children = True
 
@@ -271,9 +304,7 @@ class Widget(bf.Entity, metaclass=WidgetMeta):
         size = list(size)
         size[0] = size[0] if self.autoresize_w else None
         size[1] = size[1] if self.autoresize_h else None
-
         self.set_size(size)
-
         return self
 
     def set_size(self, size: tuple) -> Self:
@@ -305,10 +336,12 @@ class Widget(bf.Entity, metaclass=WidgetMeta):
     def build(self) -> None:
         new_size = tuple(map(int, self.rect.size))
         if self.surface.get_size() != new_size:
+            old_alpha = self.surface.get_alpha()
             new_size = [max(0, i) for i in new_size]
             self.surface = pygame.Surface(new_size, self.surface_flags)
             if self.convert_alpha:
                 self.surface = self.surface.convert_alpha()
+            self.surface.set_alpha(old_alpha)
 
     def paint(self) -> None:
         self.surface.fill((0, 0, 0, 0))

batFramework/manager.py

@@ -24,12 +24,24 @@ class Manager(bf.SceneManager):
         pygame.display.set_icon(surf)
 
     def print_status(self):
+        """
+        Print detailed information about the current state of the scenes, shared variables,
+        and additional timers managed by the subclass.
+        """
+        # Call the parent class's print_status method to include its information
         super().print_status()
-        print("TIMERS : ")
-        for r in self._timeManager.get_active_registers():
-            # print(r["timers"])
-            print("\n".join(str(t) for t in r))
-        print("-" * 40)
+        
+        # Add the timers information in a cohesive manner
+        print("\n" + "=" * 50)
+        print(" TIMERS".center(50))
+        print("=" * 50)
+        
+        # Print the timers information
+        print(self._timeManager)
+        
+        # End with a visual separator
+        print("=" * 50 + "\n")
+
 
     def get_fps(self) -> float:
         return self._clock.get_fps()

batFramework/object.py

@@ -8,7 +8,9 @@ if TYPE_CHECKING:
 
 
 class Object:
-    __instance_count = 0
+    __count = 0
+    __available_uid = set()
+    __used_uid = set()
 
     def __init__(self) -> None:
         self.rect = pygame.FRect(0, 0, 0, 0)
@@ -16,14 +18,17 @@ class Object:
         self.parent_scene: bf.Scene | None = None
         self.debug_color: tuple | str = "red"
         self.render_order: int = 0
-        self.uid: int = Object.__instance_count
-        Object.__instance_count += 1
+        self.uid: int = Object.__count
+        Object.__used_uid.add(self.uid)
 
-    @staticmethod
-    def new_uid() -> int:
-        i = Object.__instance_count
-        Object.__instance_count += 1
-        return i
+        if Object.__available_uid:
+            self.name = Object.__available_uid.pop()
+        else:
+            self.name = Object.__count
+            Object.__count += 1
+
+    def __del__(self):
+        Object.__available_uid.add(self.uid)
 
     def set_position(self, x, y) -> Self:
         self.rect.topleft = x, y
@@ -57,7 +62,11 @@ class Object:
         pass
 
     def set_uid(self, uid: int) -> Self:
+        if uid in Object.__used_uid:
+            print(f"set_uid error : UID '{uid}' is already in use")
+            return self
         self.uid = uid
+        Object.__used_uid.add(uid)
         return self
 
     def add_tags(self, *tags) -> Self:

batFramework/particle.py

@@ -7,6 +7,10 @@ class Particle:
     def __init__(self, *args, **kwargs):
         self.dead = False
         self.surface = None
+        self.generator = None
+
+    def do_when_added(self):
+        pass
 
     def update(self, dt):
         pass
@@ -21,7 +25,15 @@ class Particle:
 class TimedParticle(Particle):
     def __init__(self, duration):
         super().__init__()
-        self.timer = bf.Timer(duration, end_callback=self.kill).start()
+        self.duration = duration
+
+    def do_when_added(self):
+        if self.generator and self.generator.parent_scene:
+            self.timer = bf.SceneTimer(
+                self.duration, end_callback=self.kill,
+                scene_name=self.generator.parent_scene.name).start()        
+        else:
+            self.timer = bf.Timer(self.duration, end_callback=self.kill).start()
 
 
 class BasicParticle(TimedParticle):
@@ -36,8 +48,9 @@ class BasicParticle(TimedParticle):
         **kwargs,
     ):
         super().__init__(duration)
-        self.rect = pygame.FRect(*start_pos, *size)
-        self.surface = pygame.Surface(size).convert()
+        self.rect = pygame.FRect(0,0, *size)
+        self.rect.center = start_pos
+        self.surface = pygame.Surface(size)
         self.velocity = Vector2(start_vel)
         if color:
             self.surface.fill(color)
@@ -57,7 +70,6 @@ class BasicParticle(TimedParticle):
 
 class DirectionalParticle(BasicParticle):
     def start(self):
-        self.surface = self.surface.convert_alpha()
         self.original_surface = self.surface.copy()
 
     def update_surface(self):
@@ -72,6 +84,7 @@ class ParticleGenerator(bf.Entity):
         self.particles: list[Particle] = []
 
     def get_debug_outlines(self):
+        return
         for particle in self.particles:
             yield (
                 particle.rect.move(particle.rect.w // 2, particle.rect.h // 2),
@@ -79,7 +92,9 @@ class ParticleGenerator(bf.Entity):
             )
         yield (self.rect, "cyan")
 
-    def add_particle(self, particle):
+    def add_particle(self, particle:Particle):
+        particle.generator = self
+        particle.do_when_added()
         self.particles.append(particle)
 
     def clear(self):
@@ -94,8 +109,7 @@ class ParticleGenerator(bf.Entity):
         for p in particles_to_remove:
             self.particles.remove(p)
 
-    def draw(self, camera) -> bool:
+    def draw(self, camera) -> None:
         camera.surface.fblits(
-            [(p.surface, camera.world_to_screen(p.rect).center) for p in self.particles]
+            [(p.surface, camera.world_to_screen(p.rect)) for p in self.particles]
         )
-        return len(self.particles)

batFramework/resourceManager.py

@@ -3,6 +3,7 @@ import os
 import pygame
 import sys
 import json
+from typing import Any
 from .utils import Singleton
 
 if getattr(sys, "frozen", False):
@@ -16,6 +17,7 @@ else:
 
 class ResourceManager(metaclass=Singleton):
     def __init__(self):
+        self.shared_variables: dict[str,Any] = {}
         self.convert_image_cache = {}
         self.convert_alpha_image_cache = {}
         self.sound_cache = {}
@@ -33,11 +35,11 @@ class ResourceManager(metaclass=Singleton):
                     # print(f"Loaded image : '{file_path}'")
 
                 elif file.lower().endswith((".mp3", ".wav")):
-                    bf.AudioManager().load_sound(file.lower().split(".")[0], file_path)
+                    bf.AudioManager().load_sound(file.split(".")[0], file_path)
                     # print(f"Loaded sound : '{file_path}'")
 
                 elif file.lower().endswith((".ttf", ".otf")):
-                    bf.FontManager().load_font(file_path, file.lower().split(".")[0])
+                    bf.FontManager().load_font(file_path, file.split(".")[0])
                     # print(f"Loaded font : '{file_path}'")
 
         print(f"Loaded resources in directory : '{path}'")
@@ -82,3 +84,17 @@ class ResourceManager(metaclass=Singleton):
             return True
         except FileNotFoundError:
             return False
+
+
+    def set_sharedVar(self, name, value) -> bool:
+        """
+        Set a shared variable of any type. This will be accessible (read/write) from any scene
+        """
+        self.shared_variables[name] = value
+        return True
+
+    def get_sharedVar(self, name, error_value=None):
+        """
+        Get a shared variable
+        """
+        return self.shared_variables.get(name, error_value)

batFramework/scene.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 import re
-from typing import TYPE_CHECKING, Any
 from collections import OrderedDict
 import itertools
 
+from typing import TYPE_CHECKING, Any
 if TYPE_CHECKING:
     from .manager import Manager
     from .sceneManager import SceneManager
@@ -27,6 +27,7 @@ class Scene:
         """
         self.scene_index = 0
         self.name = name
+        bf.TimeManager().add_register(self.name,False)
         self.manager: Manager | None = None
         self.active = False
         self.visible = False
@@ -36,10 +37,16 @@ class Scene:
         self.early_actions: bf.ActionContainer = bf.ActionContainer()
         self.camera: bf.Camera = bf.Camera(convert_alpha=world_convert_alpha)
         self.hud_camera: bf.Camera = bf.Camera(convert_alpha=hud_convert_alpha)
-
+        self.should_sort :bool = True
         self.root: bf.Root = bf.Root(self.hud_camera)
         self.root.rect.center = self.hud_camera.get_center()
         self.add_hud_entity(self.root)
+        self.entities_to_remove = []
+        self.entities_to_add = []
+
+
+    def __str__(self)->str:
+        return f"Scene({self.name})"
 
     def get_world_entity_count(self) -> int:
         return len(self.world_entities)
@@ -130,31 +137,33 @@ class Scene:
 
     def add_world_entity(self, *entities: bf.Entity):
         """Add world entities to the scene."""
+        change = False
         for e in entities:
-            if e not in self.world_entities:
-                self.world_entities[e] = None
-                e.parent_scene = self
-                e.do_when_added()
-        self.sort_entities()
-
+            if e not in self.world_entities and e not in self.entities_to_add:
+                change = True
+                # self.world_entities[e] = None
+                self.entities_to_add.append(e)
+                e.set_parent_scene(self)
+        # self.sort_entities()
+        return change
+
+    # Updated remove_world_entity method to add entities to the removal list
     def remove_world_entity(self, *entities: bf.Entity):
-        """Remove world entities from the scene."""
-        removed = False
+        """Mark world entities for removal from the scene."""
+        change = False
         for e in entities:
             if e in self.world_entities:
-                e.do_when_removed()
-                e.parent_scene = None
-                del self.world_entities[e]
-                removed = True
-        return removed
+                change = True
+                self.entities_to_remove.append(e)
+                e.set_parent_scene(None)
+        return change
 
     def add_hud_entity(self, *entities: bf.Entity):
         """Add HUD entities to the scene."""
         for e in entities:
             if e not in self.hud_entities:
                 self.hud_entities[e] = None
-                e.parent_scene = self
-                e.do_when_added()
+                e.set_parent_scene(self)
         self.sort_entities()
         return True
 
@@ -162,9 +171,8 @@ class Scene:
         """Remove HUD entities from the scene."""
         for e in entities:
             if e in self.hud_entities:
-                e.do_when_removed()
-                e.parent_scene = None
-                del self.hud_entities[e]
+                e.set_parent_scene(None)
+                self.hud_entities.pop(e)
 
     def add_actions(self, *action):
         """Add actions to the scene."""
@@ -255,16 +263,32 @@ class Scene:
 
     def update(self, dt):
         """Update the scene. Do NOT override"""
+        if self.should_sort:
+            self._sort_entities_internal()
+
         for entity in itertools.chain(
             self.hud_entities.keys(), self.world_entities.keys()
         ):
             entity.update(dt)
+        
         self.do_update(dt)
         self.camera.update(dt)
         self.hud_camera.update(dt)
         self.actions.reset()
         self.early_actions.reset()
 
+
+        if self.entities_to_add:
+            for e in self.entities_to_add:
+                self.world_entities[e] = None
+            self.entities_to_add.clear()
+
+        # Remove marked entities after updating
+        if self.entities_to_remove:
+            for e in self.entities_to_remove:
+                self.world_entities.pop(e, None)
+            self.entities_to_remove.clear()
+
     def do_update(self, dt):
         """Specific update within the scene."""
         pass
@@ -284,6 +308,9 @@ class Scene:
         [draw_rect(data) for data in entity.get_debug_outlines()]
 
     def sort_entities(self) -> None:
+        self.should_sort = True
+
+    def _sort_entities_internal(self):
         """Sort entities within the scene based on their rendering order."""
         self.world_entities = OrderedDict(
             sorted(self.world_entities.items(), key=lambda e: e[0].render_order)
@@ -291,6 +318,7 @@ class Scene:
         self.hud_entities = OrderedDict(
             sorted(self.hud_entities.items(), key=lambda e: e[0].render_order)
         )
+        self.should_sort = False
 
     def draw(self, surface: pygame.Surface):
         self.camera.clear()
@@ -329,6 +357,7 @@ class Scene:
         self.root.clear_hovered()
         # self.root.clear_focused()
         self.root.build()
+        bf.TimeManager().activate_register(self.name)
         self.do_on_enter()
         # self.root.visit(lambda e : e.resolve_constraints())
 
@@ -339,6 +368,7 @@ class Scene:
         self.set_visible(False)
         self.actions.hard_reset()
         self.early_actions.hard_reset()
+        bf.TimeManager().deactivate_register(self.name)
         self.do_on_exit()
 
     def do_on_enter(self) -> None:

batFramework/sceneManager.py

@@ -10,16 +10,15 @@ def swap(lst, index1, index2):
 class SceneManager:
     def __init__(self) -> None:
         self.scenes: list[bf.Scene] = []
-        self.shared_variables: dict = {}
         self.shared_events = {pygame.WINDOWRESIZED}
 
         self.set_sharedVar("in_cutscene", False)
         self.set_sharedVar("player_has_control", True)
-
+        self.old_player_control = True
         self.debug_mode: bf.enums.debugMode = bf.debugMode.HIDDEN
         self.current_transitions: dict[str, bf.transition.Transition] = {}
 
-    def init_scenes(self, *initial_scenes):
+    def init_scenes(self, *initial_scenes:bf.Scene):
         for index, s in enumerate(initial_scenes):
             s.set_scene_index(index)
         for s in reversed(initial_scenes):
@@ -36,33 +35,55 @@ class SceneManager:
 
     def print_status(self):
         """
-        Print some information about the current state of the scenes.
-        """
-        print("-" * 40)
-        print(
-            "\n".join(
-                f" {s.name:<30}\t{'Active' if s.active else 'Inactive'}\t{'Visible' if s.visible else 'Invisible'}\tindex= {s.scene_index}"
-                for s in self.scenes
-            )
-        )
-        print(f"[Debugging] = {self.debug_mode}")
-        print("---SHARED VARIABLES---")
-        for name, value in self.shared_variables.items():
-            print(f"[{str(name)} = {str(value)}]")
-        print("-" * 40)
-
-    def set_sharedVar(self, name, value) -> bool:
-        """
-        Set a shared variable of any type. This will be accessible (read/write) from any scene
+        Print detailed information about the current state of the scenes and shared variables.
         """
-        self.shared_variables[name] = value
-        return True
+
+        def format_scene_info(scene):
+            status = 'Active' if scene.active else 'Inactive'
+            visibility = 'Visible' if scene.visible else 'Invisible'
+            return f"{scene.name:<30} | {status:<8} | {visibility:<10} | Index={scene.scene_index}"
+
+        def format_shared_variable(name, value):
+            return f"[{name}] = {value}"
+
+        print("\n" + "=" * 50)
+        print(" SCENE STATUS".center(50))
+        print("=" * 50)
+
+        # Print scene information
+        if self.scenes:
+            header = f"{'Scene Name':<30} | {'Status':<8} | {'Visibility':<10} | {'Index':<7}"
+            print(header)
+            print("-" * 50)
+            print("\n".join(format_scene_info(s) for s in self.scenes))
+        else:
+            print("No scenes available.")
+
+        # Print debugging mode status
+        print("\n" + "=" * 50)
+        print(" DEBUGGING STATUS".center(50))
+        print("=" * 50)
+        print(f"[Debugging Mode] = {self.debug_mode}")
+
+        # Print shared variables
+        print("\n" + "=" * 50)
+        print(" SHARED VARIABLES".center(50))
+        print("=" * 50)
+
+        if bf.ResourceManager().shared_variables:
+            for name, value in bf.ResourceManager().shared_variables.items():
+                print(format_shared_variable(name, value))
+        else:
+            print("No shared variables available.")
+
+        print("=" * 50 + "\n")
+
+
+    def set_sharedVar(self, name, value) -> None:
+        bf.ResourceManager().set_sharedVar(name,value)
 
     def get_sharedVar(self, name, error_value=None):
-        """
-        Get a shared variable
-        """
-        return self.shared_variables.get(name, error_value)
+        return bf.ResourceManager().get_sharedVar(name, error_value)
 
     def get_current_scene_name(self) -> str:
         """get the name of the current scene"""
@@ -129,11 +150,11 @@ class SceneManager:
     def _start_transition(self, target_scene: bf.Scene):
         target_scene.set_active(True)
         target_scene.set_visible(True)
+        self.old_player_control = bool(self.get_sharedVar("player_has_control"))
         self.set_sharedVar("player_has_control", False)
 
     def _end_transition(self, scene_name, index):
         self.set_scene(scene_name, index, True)
-        self.set_sharedVar("player_has_control", True)
         self.current_transitions.clear()
 
     def set_scene(self, scene_name, index=0, ignore_early: bool = False):
@@ -156,6 +177,9 @@ class SceneManager:
             self.scenes[index].do_on_enter_early()
         target_scene.on_enter()
 
+        self.set_sharedVar("player_has_control", self.old_player_control)
+
+
     def cycle_debug_mode(self):
         current_index = self.debug_mode.value
         next_index = (current_index + 1) % len(bf.debugMode)