batframework 0.1.13__py3-none-any.whl → 1.0.1__py3-none-any.whl

batFramework/gui/widget.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 from typing import TYPE_CHECKING
+
 if TYPE_CHECKING:
     from .constraints import Constraint
     from .root import Root
@@ -9,106 +10,110 @@ import batFramework as bf
 import pygame
 from math import ceil
 
-
+MAX_CONSTRAINT_ITERATION = 10
 
 class Widget(bf.Entity):
-    def __init__(self,convert_alpha=True)->None:
+    def __init__(self, convert_alpha=True) -> None:
         super().__init__(convert_alpha=convert_alpha)
         self.autoresize = False
-        self.parent : None|Self = None 
-        self.is_root :bool = False
-        self.children : list["Widget"] = []
-        self.focusable :bool= False
-        self.constraints : list[Constraint] = []
-        self.gui_depth : int = 0
-        if self.surface : self.surface.fill("white")
+        self.parent: None | Self = None
+        self.is_root: bool = False
+        self.children: list["Widget"] = []
+        self.focusable: bool = False
+        self.constraints: list[Constraint] = []
+        self.gui_depth: int = 0
+        if self.surface:
+            self.surface.fill("white")
         self.set_debug_color("red")
-        self.padding :tuple[float|int,...]= (0,0,0,0) 
+        self.padding: tuple[float | int, ...] = (0, 0, 0, 0)
 
-    def set_padding(self,value : float|int|tuple|list)->Self:
+    def set_padding(self, value: float | int | tuple | list) -> Self:
         old_raw_size = (
             self.rect.w - self.padding[0] - self.padding[2],
-            self.rect.h - self.padding[1] - self.padding[3]
+            self.rect.h - self.padding[1] - self.padding[3],
         )
-        if isinstance(value,list) or isinstance(value,tuple):
-            if len(value) > 4 : pass
-            elif any(v<0 for v in value) : pass
+        if isinstance(value, list) or isinstance(value, tuple):
+            if len(value) > 4:
+                pass
+            elif any(v < 0 for v in value):
+                pass
             elif len(value) == 2:
-                self.padding = (value[0],value[1],value[0],value[1])
+                self.padding = (value[0], value[1], value[0], value[1])
             else:
-                self.padding = (*value, *self.padding[len(value):])
+                self.padding = (*value, *self.padding[len(value) :])
         else:
-            self.padding = (value,)*4
+            self.padding = (value,) * 4
 
         self.set_size(
-            old_raw_size[0] + self.padding[0] +  self.padding[2],
-            old_raw_size[1] + self.padding[1] +  self.padding[3],
+            old_raw_size[0] + self.padding[0] + self.padding[2],
+            old_raw_size[1] + self.padding[1] + self.padding[3],
         )
-        if self.parent :
-            self.apply_constraints()
-            self.parent.children_modified()
         return self
-        
-    def inflate_rect_by_padding(self,rect:pygame.FRect)->pygame.FRect:
+
+
+    def inflate_rect_by_padding(self, rect: pygame.FRect) -> pygame.FRect:
         return pygame.FRect(
             rect[0] - self.padding[0],
-            rect[1]  - self.padding[1],
-            rect[2] + self.padding[0]+self.padding[2],
-            rect[3] + self.padding[1]+self.padding[3]   
+            rect[1] - self.padding[1],
+            rect[2] + self.padding[0] + self.padding[2],
+            rect[3] + self.padding[1] + self.padding[3],
         )
-    def get_content_left(self)->float:
+    def get_min_required_size(self)->tuple[float,float]:
+        return self.rect.size
+
+    def get_content_left(self) -> float:
         return self.rect.left + self.padding[0]
 
-    def get_content_top(self)->float:
+    def get_content_top(self) -> float:
         return self.rect.top + self.padding[1]
 
-    def get_content_right(self)->float:
+    def get_content_right(self) -> float:
         return self.rect.right - self.padding[2]
 
-    def get_content_bottom(self)->float:
+    def get_content_bottom(self) -> float:
         return self.rect.bottom - self.padding[3]
 
-    def get_content_width(self)->float:
+    def get_content_width(self) -> float:
         return self.rect.w - self.padding[0] - self.padding[2]
 
-    def get_content_height(self)->float:
+    def get_content_height(self) -> float:
         return self.rect.h - self.padding[1] - self.padding[3]
 
-    def get_content_rect(self)->pygame.FRect:
+    def get_content_rect(self) -> pygame.FRect:
         return pygame.FRect(
-            self.rect.left      + self.padding[0],
-            self.rect.top       + self.padding[1],
+            self.rect.left + self.padding[0],
+            self.rect.top + self.padding[1],
             self.get_content_width(),
-            self.get_content_height()
+            self.get_content_height(),
         )
 
-    def get_content_rect_rel(self)->pygame.FRect:
-        return self.get_content_rect().move(-self.rect.left,-self.rect.top)
+    def get_content_rect_rel(self) -> pygame.FRect:
+        return self.get_content_rect().move(-self.rect.left, -self.rect.top)
 
-    def get_content_center(self)->tuple[float,float]:
+    def get_content_center(self) -> tuple[float, float]:
         return self.get_content_rect().center
 
-    def get_depth(self)->int:
-        if self.is_root or self.parent is None : 
+    def get_depth(self) -> int:
+        if self.is_root or self.parent is None:
             self.gui_depth = 0
         else:
-            self.gui_depth =  self.parent.get_depth() + 1
+            self.gui_depth = self.parent.get_depth() + 1
         return self.gui_depth
 
     def top_at(self, x: float, y: float) -> "None|Widget":
         if self.children:
             for child in reversed(self.children):
-                r = child.top_at(x,y)
+                r = child.top_at(x, y)
                 if r is not None:
                     return r
-        if self.rect.collidepoint(x,y) and self.visible:
+        if self.rect.collidepoint(x, y) and self.visible:
             return self
         return None
-            
-    def get_constraint(self,name:str)->Constraint|None:
+
+    def get_constraint(self, name: str) -> Constraint | None:
         return next((c for c in self.constraints if c.name == name), None)
 
-    def add_constraints(self,*constraints:Constraint)->Self:
+    def add_constraints(self, *constraints: Constraint) -> Self:
         for constraint in constraints:
             c = self.get_constraint(constraint.name)
             if c is not None:
@@ -117,16 +122,15 @@ class Widget(bf.Entity):
         self.apply_constraints()
         return self
 
-
-    def has_constraint(self,name:str)->bool:
+    def has_constraint(self, name: str) -> bool:
         return any(c.name == name for c in self.constraints)
 
-    def apply_all_constraints(self)->None:
-        # print("APPLY ALL CONSTRAINTS IN ",self.to_string())
+    def apply_all_constraints(self) -> None:
+        for child in self.children:
+            child.apply_all_constraints()
         self.apply_constraints()
-        for child in self.children : child.apply_all_constraints()
-    
-    def apply_constraints(self, max_iterations: int = 10) -> None:
+
+    def apply_constraints(self) -> None:
         if not self.parent:
             # print(f"Warning : can't apply constraints on {self.to_string()} without parent widget")
             return
@@ -135,7 +139,7 @@ class Widget(bf.Entity):
         # Sort constraints based on priority
         self.constraints.sort(key=lambda c: c.priority)
 
-        for iteration in range(max_iterations):
+        for iteration in range(MAX_CONSTRAINT_ITERATION):
             unsatisfied = []  # Initialize a flag
 
             for constraint in self.constraints:
@@ -143,61 +147,74 @@ class Widget(bf.Entity):
                     unsatisfied.append(constraint)
                     constraint.apply(self.parent, self)
             if not unsatisfied:
-            #     data = ''.join(f"\n\t->{c.to_string()}" for c in self.constraints)
-            #     print(self.get_depth()*'\t'+f"Following constraints of {self.to_string()} were all satisfied :{data}")
+                #     data = ''.join(f"\n\t->{c.to_string()}" for c in self.constraints)
+                #     print(self.get_depth()*'\t'+f"Following constraints of {self.to_string()} were all satisfied :{data}")
                 break
             # print(f"pass {iteration}/{max_iterations} : unsatisfied = {';'.join(c.to_string() for c in unsatisfied)}")
-            if iteration == max_iterations - 1:
-                raise ValueError(f"[WARNING] Following constraints for {self.to_string()} were not satisfied : \n\t{';'.join([c.to_string() for c in unsatisfied])}")
+            if iteration == MAX_CONSTRAINT_ITERATION - 1:
+                unsatisfied_constraints = '\n\t'.join([c.to_string() for c in unsatisfied])
+                raise ValueError(
+                    f"[WARNING] Following constraints for {self.to_string()} were not satisfied : \n{unsatisfied_constraints}"
+                    )
 
     # GETTERS
-    def get_by_tags(self,*tags):
+    def get_by_tags(self, *tags :str):
         for c in self.children:
             yield from c.get_by_tags(*tags)
-        if any(self.has_tag(t) for t in tags):
+        if any(self.has_tags(t) for t in tags):
             yield self
 
-    def get_root(self)-> Self|Root|None:
-        if self.is_root: return self
-        if self.parent_scene is not None : return self.parent_scene.root
-        return None if self.parent is None else self.parent.get_root()
+    def count_children_recursive(self):
+        return 1 + sum(child.count_children_recursive() for child in self.children)
+
 
-    def get_size_int(self)->tuple[int,int]:
-        return (ceil(self.rect.width),ceil(self.rect.height))
+    def propagate_function(self,function):
+        function(self)
+        for child in self.children:
+            child.propagate_function(function)
 
+    def get_root(self) -> Root | None:
+        if self.parent_scene is not None:
+            return self.parent_scene.root
+        return None if self.parent is None else self.parent.get_root()
 
-    def get_center(self)->tuple[float,float]:
-        return self.rect.center
+    def get_size_int(self) -> tuple[int, int]:
+        return (ceil(self.rect.width), ceil(self.rect.height))
 
+    def get_center(self) -> tuple[float, float]:
+        return self.rect.center
 
     def get_bounding_box(self):
-        yield (self.rect,self._debug_color)
-        yield (self.get_content_rect(),"yellow")
+        yield (self.rect, self.debug_color)
+        yield (self.get_content_rect(), "yellow")
         for child in self.children:
             yield from child.get_bounding_box()
 
-    def set_autoresize(self,value:bool)-> Self:
+    def set_autoresize(self, value: bool) -> Self:
         self.autoresize = value
         self.build()
         return self
 
-    def set_parent(self,parent:Self|None)->None:
+    def set_parent(self, parent: Self | None) -> Self:
         if self.parent:
             self.parent.remove_child(self)
         self.parent = parent
         self.apply_all_constraints()
+        return self
+
     # SETTERS
-    
+
     def set_root(self) -> Self:
         self.is_root = True
         return self
 
-    def set_parent_scene(self,scene)->None:
+    def set_parent_scene(self, scene) -> Self:
         super().set_parent_scene(scene)
-        for child in self.children : 
+        for child in self.children:
             child.set_parent_scene(scene)
-
-    def set_x(self,x:float)->Self:
+        return self
+    def set_x(self, x: float) -> Self:
+        if x == self.rect.x : return self
         delta = x - self.rect.x
         self.rect.x = x
         for child in self.children:
@@ -205,117 +222,120 @@ class Widget(bf.Entity):
         self.apply_constraints()
         return self
 
-    def set_y(self,y:float)->Self:
+    def set_y(self, y: float) -> Self:
+        if y == self.rect.y : return self
         delta = y - self.rect.y
         self.rect.y = y
         for child in self.children:
             child.set_y(child.rect.y + delta)
         self.apply_constraints()
-
         return self
 
-    def set_position(self,x:float,y:float)->Self:
+    def set_position(self, x: float, y: float) -> Self:
+        if self.rect.topleft == (x,y) : return self
         delta_x = x - self.rect.x
         delta_y = y - self.rect.y
-        self.rect.topleft = x,y
+        self.rect.topleft = x, y
         for child in self.children:
-            child.set_position(child.rect.x + delta_x,child.rect.y+delta_y)
+            child.set_position(child.rect.x + delta_x, child.rect.y + delta_y)
         self.apply_constraints()
         return self
-        
-    def set_center(self,x:float,y:float)->Self:
+
+    def set_center(self, x: float, y: float) -> Self:
+        if self.rect.center == (x,y) : return self
         delta_x = x - self.rect.centerx
         delta_y = y - self.rect.centery
-        self.rect.center = x,y
+        self.rect.center = x, y
         for child in self.children:
-            child.set_position(child.rect.x + delta_x,child.rect.y+delta_y)
+            child.set_position(child.rect.x + delta_x, child.rect.y + delta_y)
         self.apply_constraints()
         return self
 
-
-    def set_size(self, width : float, height: float) -> Self:
-        self.rect.size = (width,height)
+    def set_size(self, width: float, height: float) -> Self:
+        if self.rect.size == (width,height) : return self
+        self.rect.size = (width, height)
         self.build()
-
+        self.apply_constraints()
+        self.children_modified()
         return self
-        
 
     # Other Methods
 
-    def print_tree(self,ident:int=0)->None:
-        print('\t'*ident+self.to_string()+(':' if self.children else ''))
-        for child in self.children :
-            child.print_tree(ident+1)
+    def print_tree(self, ident: int = 0) -> None:
+        print("\t" * ident + self.to_string() + (":" if self.children else ""))
+        for child in self.children:
+            child.print_tree(ident + 1)
 
-    def to_string(self)->str:
-        
+    def to_string(self) -> str:
         return f"{self.to_string_id()}@{*self.rect.topleft,* self.rect.size}"
 
-
-    def to_string_id(self)->str:
+    def to_string_id(self) -> str:
         return "Widget"
 
-
-    def do_when_removed(self)->None:
+    def do_when_removed(self) -> None:
         if self.parent_scene and self.parent == self.parent_scene.root:
             self.set_parent(None)
 
     # Methods on children
 
-    def add_child(self,*child:"Widget")->None:
-        for c in child : 
+    def add_child(self, *child: "Widget") -> None:
+        for c in child:
             self.children.append(c)
             c.set_parent(self)
             c.set_parent_scene(self.parent_scene)
-            c.apply_constraints()
-        self.apply_constraints()
+            c.do_when_added()
+        self.apply_all_constraints()
         self.children_modified()
 
-    def remove_child(self,child:Self)->None:
-        self.children.remove(child)
+    def remove_child(self, child: "Widget") -> None:
+        try : 
+            self.children.remove(child)
+        except ValueError:
+            return
         child.set_parent(None)
+        child.do_when_removed()
         child.set_parent_scene(None)
-        self.apply_constraints()
+        self.apply_all_constraints()
         self.children_modified()
 
 
-
-
     # if return True -> don't propagate to siblings or parents
-    def process_event(self, event: pygame.Event)->bool:
-    
+    def process_event(self, event: pygame.Event) -> bool:
         # First propagate to children
         for child in self.children:
             if child.process_event(event):
                 return True
-         #return True if the method is blocking (no propagation to next children of the scene)
+        # return True if the method is blocking (no propagation to next children of the scene)
         return super().process_event(event)
 
-
-    def update(self,dt:float):
+    def update(self, dt: float):
         for child in self.children:
             child.update(dt)
+        self.do_update(dt)
 
     def draw(self, camera: bf.Camera) -> int:
-        self.children.sort(key=lambda e: (e.z_depth,e.render_order))
-        return super().draw(camera) + sum([child.draw(camera) for child in self.children])
+        return super().draw(camera) + sum(
+            [child.draw(camera) for child in self.children]
+        )
 
-    def build(self)->None:
+    def build(self) -> None:
         """
         This function is called each time the widget's surface has to be updated
         It usually has to be overriden if inherited to suit the needs of the new class
         """
-        if not self.surface: return
+        if not self.surface:
+            return
         if self.surface.get_size() != self.get_size_int():
             self.surface = pygame.Surface(self.get_size_int())
-            self.apply_constraints()
-            if self.parent : 
-                self.parent.children_modified()
 
-    def build_all(self)->None:
+
+    def build_all(self) -> None:
+        self.build()
         for child in self.children:
             child.build_all()
-        self.build()
-    def children_modified(self)->None:
+
+    def children_modified(self) -> None:
         if self.parent and not self.is_root:
             self.parent.children_modified()
+
+

batFramework/manager.py

@@ -2,32 +2,36 @@ import batFramework as bf
 import pygame
 import random
 
+
 class Manager(bf.SceneManager):
     def __init__(self, *initial_scene_list) -> None:
-        random.seed("random")
-        self._screen: pygame.Surface = bf.const.SCREEN
-        self._timeManager = bf.Time()
+        # random.seed("random")
+        self._screen: pygame.Surface|None = bf.const.SCREEN
+        self._timeManager = bf.TimeManager()
         self._cutsceneManager = bf.CutsceneManager(self)
         self._clock: pygame.Clock = pygame.Clock()
+        self.do_pre_init()
         super().__init__(*initial_scene_list)
         self.set_sharedVar("clock", self._clock)
         self.do_init()
 
     @staticmethod
-    def set_icon(path: str):
-        surf = pygame.image.load(bf.utils.get_path(path)).convert_alpha()
+    def set_icon(path: str)->None:
+        surf = pygame.image.load(bf.ResourceManager().get_path(path)).convert_alpha()
         pygame.display.set_icon(surf)
 
-    def get_fps(self):
+    def get_fps(self)->float:
         return self._clock.get_fps()
 
-    def do_init(self):
+    def do_init(self)->None:
         pass
 
-    def stop(self)->None:
+    def do_pre_init(self)->None:
+        pass
+    def stop(self) -> None:
         self._running = False
 
-    def run(self):
+    def run(self)->None:
         self._running = True
         dt: float = 0
         while self._running:
@@ -36,13 +40,14 @@ class Manager(bf.SceneManager):
                     self._running = False
                     break
                 if event.type == pygame.VIDEORESIZE:
-                    bf.const.set_resolution((event.w,event.h))
+                    bf.const.set_resolution((event.w, event.h))
                 self.process_event(event)
             # update
-            dt = self._clock.tick(bf.const.FPS if  not bf.const.VSYNC else 0) / 1000
-            dt = min(dt, 0.02)
+            # dt = self._clock.tick(bf.const.FPS if not bf.const.VSYNC else 0) / 1000
+            dt = self._clock.tick(0 if  bf.const.VSYNC else bf.const.FPS) / 1000
+            # dt = min(dt, 0.02) dirty fix for dt being too high when window not focused for a long time
             self._cutsceneManager.update(dt)
-            self._timeManager.update()
+            self._timeManager.update(dt)
             self.update(dt)
             # render
             self.draw(self._screen)

batFramework/particles.py

@@ -3,10 +3,8 @@ import pygame
 from pygame.math import Vector2
 
 
-
 class Particle:
-
-    def __init__(self,*args,**kwargs):
+    def __init__(self, *args, **kwargs):
         self.dead = False
         self.surface = None
 
@@ -18,18 +16,20 @@ class Particle:
 
 
 class TimedParticle(Particle):
-    def __init__(self,duration):
+    def __init__(self, duration):
         super().__init__()
         self.start_time = pygame.time.get_ticks()
         self.duration = duration
         self.progression = 0
+
     def update(self, dt):
         if self.dead:
             return
         elapsed_time = pygame.time.get_ticks() - self.start_time
         self.progression = elapsed_time / self.duration
         self.dead = elapsed_time >= self.duration
-        
+
+
 class BasicParticle(TimedParticle):
     def __init__(
         self,
@@ -37,7 +37,7 @@ class BasicParticle(TimedParticle):
         start_vel: tuple[float, float],
         duration=1000,
         color=None,
-        size = (4,4)
+        size=(4, 4),
     ):
         super().__init__()
         self.rect = pygame.FRect(*start_pos, 0, 0)
@@ -50,12 +50,11 @@ class BasicParticle(TimedParticle):
         super().update(dt)
         self.rect.center += self.velocity * dt
         self.update_surface()
-        
+
     def update_surface(self):
         self.surface.set_alpha(255 - int(self.progression * 255))
 
 
-
 class ParticleManager(bf.Entity):
     def __init__(self) -> None:
         super().__init__(size=bf.const.RESOLUTION)
@@ -68,10 +67,8 @@ class ParticleManager(bf.Entity):
     def add_particle(self, particle=Particle):
         self.particles.append(particle)
 
-
     def clear(self):
         self.particles = []
-        
 
     def update(self, dt: float):
         particles_to_remove = []
@@ -83,13 +80,19 @@ class ParticleManager(bf.Entity):
             self.particles.remove(p)
 
     def draw(self, camera) -> bool:
-        for p in self.particles : p.update_surface()
+        for p in self.particles:
+            p.update_surface()
         camera.surface.fblits(
             [
                 (
                     p.surface,
-                    tuple(round(i * self.z_depth) for i in camera.transpose(self.rect).topleft)
-                ) for p in self.particles if p.surface
+                    tuple(
+                        round(i * self.z_depth)
+                        for i in camera.transpose(self.rect).topleft
+                    ),
+                )
+                for p in self.particles
+                if p.surface
             ]
         )
         return len(self.particles)

batFramework/resourceManager.py

@@ -0,0 +1,55 @@
+import batFramework as bf
+import os
+import pygame
+import sys
+from .utils import Singleton
+if getattr(sys, "frozen", False):
+    # If the application is run as a bundle, the PyInstaller bootloader
+    # extends the sys module by a flag frozen=True and sets the app
+    # path into variable _MEIPASS'.
+    application_path = sys._MEIPASS
+else:
+    application_path = os.getcwd()
+
+
+class ResourceManager(metaclass=Singleton):
+    def __init__(self):
+        self.convert_image_cache = {}
+        self.convert_alpha_image_cache = {}
+        self.sound_cache = {}
+        self.RESOURCE_PATH = "."
+
+    def load_dir(self,path)->None:
+        for root, dirs, files in os.walk(path):
+            for file in files:
+                file_path = os.path.join(root, file)
+                if file.lower().endswith(('.png', '.jpg', '.jpeg', '.gif')):
+                    self.load_image(file_path)
+                elif file.lower().endswith(('.mp3', '.wav')):
+                    self.load_sound(file_path)
+
+    def set_resource_path(self,path: str):
+        self.RESOURCE_PATH = os.path.join(application_path, path)
+        print(f"set resource path to '{self.RESOURCE_PATH}'")
+        
+
+    def get_path(self,path: str):
+        return os.path.join(self.RESOURCE_PATH, path)
+        
+    def load_image(self,path)->None:
+        key = self.get_path(path)
+        if key in self.convert_image_cache : return
+        self.convert_image_cache[key] = pygame.image.load(path).convert()
+        self.convert_alpha_image_cache[key] = pygame.image.load(path).convert_alpha()
+        
+    def load_sound(self,path)->None:
+        pass
+        
+    def get_image(self,path,convert_alpha:bool=False):   
+        key = self.get_path(path)
+        return self.convert_alpha_image_cache.get(key,None) if\
+         convert_alpha else self.convert_image_cache.get(key,None)
+    
+    def get_sound(self,path):
+        return None
+