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

batFramework/gui/toggle.py

@@ -6,7 +6,7 @@ import pygame
 
 
 class Toggle(Button):
-    def __init__(self, text: str, callback=None, default_value: bool = False) -> None:
+    def __init__(self, text: str = "", callback=None, default_value: bool = False) -> None:
         self.value: bool = default_value
         self.indicator: ToggleIndicator = ToggleIndicator(default_value)
         self.gap: float | int = 0
@@ -55,37 +55,31 @@ class Toggle(Button):
     def get_min_required_size(self) -> tuple[float, float]:
         if not self.text_rect:
             self.text_rect.size = self._get_text_rect_required_size()
-        w, h = self.text_rect.size
-        outline_offset = self._get_outline_offset()
-
         size = (
             max(
-                self.indicator.rect.w,
-                w + self.font_object.point_size + (self.gap if self.text else 0),
+                self.indicator.get_min_required_size()[0],
+                self.text_rect.w + self.font_object.point_size + (self.gap if self.text else 0),
             ),
-            self.text_rect.h + outline_offset[1],
+            self.text_rect.h,
         )
         return self.inflate_rect_by_padding((0, 0, *size)).size
 
     def _build_layout(self) -> None:
-
         gap = self.gap if self.text else 0
-
         self.text_rect.size = self._get_text_rect_required_size()
 
-        outline_offset = self._get_outline_offset()
+        #right part size
+        right_part_height = min(self.text_rect.h, self.font_object.point_size)
+        self.indicator.set_size_if_autoresize((right_part_height,right_part_height))
 
-        tmp_rect = pygame.FRect(
-            0, 0,
-            self.text_rect.w + gap + self.indicator.rect.w + outline_offset[0],
-            self.text_rect.h + outline_offset[1]
+        #join left and right
+        joined_rect = pygame.FRect(
+            0, 0, self.text_rect.w + gap + self.indicator.rect.w, self.text_rect.h 
         )
 
-        point_size = min(tmp_rect.h, self.font_object.point_size)
-        self.indicator.set_size_if_autoresize((point_size,point_size))
 
         if self.autoresize_h or self.autoresize_w:
-            target_rect = self.inflate_rect_by_padding(tmp_rect)
+            target_rect = self.inflate_rect_by_padding(joined_rect)
             if not self.autoresize_w:
                 target_rect.w = self.rect.w
             if not self.autoresize_h:
@@ -95,14 +89,15 @@ class Toggle(Button):
                 self.build()
                 return
 
+        # ------------------------------------ size is ok
 
+        offset = self._get_outline_offset() if self.show_text_outline else (0,0)
         padded_rect = self.get_padded_rect()
         padded_relative = padded_rect.move(-self.rect.x, -self.rect.y)
 
- 
+        self.align_text(joined_rect, padded_relative.move( offset), self.alignment)
+        self.text_rect.midleft = joined_rect.midleft
 
-        self.align_text(tmp_rect, padded_relative, self.alignment)
-        self.text_rect.midleft = tmp_rect.midleft
         if self.text:
             match self.spacing:
                 case bf.spacing.MAX:
@@ -110,5 +105,8 @@ class Toggle(Button):
                 case bf.spacing.MIN:
                     gap = 0
 
-        self.indicator.rect.x = self.rect.x + self.text_rect.right + gap
-        self.indicator.rect.centery = self.rect.y + padded_relative.top + self.text_rect.h // 2
+        pos = self.text_rect.move(
+                self.rect.x + gap -offset[0],
+                self.rect.y + (self.text_rect.h / 2) - (right_part_height/ 2) -offset[1],
+            ).topright
+        self.indicator.rect.topleft = pos

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
 
@@ -194,41 +196,69 @@ class Widget(bf.Entity, metaclass=WidgetMeta):
         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
 

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):
@@ -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)) for p in self.particles]
         )
-        return len(self.particles)

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

batFramework/sceneManager.py

@@ -35,20 +35,49 @@ class SceneManager:
 
     def print_status(self):
         """
-        Print some information about the current state of the scenes.
+        Print detailed information about the current state of the scenes and shared variables.
         """
-        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 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)

batFramework/stateMachine.py

@@ -7,11 +7,11 @@ class StateMachine: ...
 class State:
     def __init__(self, name: str) -> None:
         self.name = name
-        self.parent_entity: bf.Entity | bf.AnimatedSprite = None
+        self.parent: bf.Entity | bf.AnimatedSprite = None
         self.state_machine: StateMachine = None
 
-    def set_parent_entity(self, parent_entity: bf.Entity | bf.AnimatedSprite):
-        self.parent_entity = parent_entity
+    def set_parent(self, parent: bf.Entity | bf.AnimatedSprite):
+        self.parent = parent
 
     def set_stateMachine(self, stateMachine):
         self.state_machine = stateMachine
@@ -27,16 +27,19 @@ class State:
 
 
 class StateMachine:
-    def __init__(self, parent_entity) -> None:
+    def __init__(self, parent) -> None:
         self.states: dict[str, State] = {}
-        self.parent_entity = parent_entity
+        self.parent = parent
         self.current_state = None
 
     def add_state(self, state: State):
         self.states[state.name] = state
-        state.set_parent_entity(self.parent_entity)
+        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:

batFramework/templates/__init__.py

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

batFramework/templates/character.py

@@ -0,0 +1,44 @@
+import batFramework as bf
+import pygame
+from .states import *
+
+class Platform2DCharacter(bf.Character):
+    def __init__(self):
+        super().__init__()
+        self.actions = bf.ActionContainer(
+            *bf.DirectionalKeyControls(),
+            bf.Action("jump").add_key_control(pygame.K_SPACE).set_holding()
+        )
+        self.on_ground : bool = False
+        self.max_jumps = 2
+        self.jump_counter = 0
+        self.jump_force = 150
+        self.speed = 100
+        self.acceleration = 30
+        self.friction = 0.7
+        self.gravity = 300
+        self.terminal_velocity = 1000
+        self.state_machine.set_state("idle")
+        
+
+    def do_setup_animations(self):
+        self.add_animation(bf.Animation("idle"))
+        self.add_animation(bf.Animation("run"))
+        self.add_animation(bf.Animation("jump"))
+        self.add_animation(bf.Animation("fall"))
+
+
+    def do_setup_states(self):
+        self.state_machine.add_state(Platform2DIdle())
+        self.state_machine.add_state(Platform2DRun())
+        self.state_machine.add_state(Platform2DJump())
+        self.state_machine.add_state(Platform2DFall())
+
+
+
+    def do_reset_actions(self) -> None:
+        self.actions.reset()
+
+    def do_process_actions(self, event: pygame.Event) -> None:
+        self.actions.process_event(event)
+