batframework 1.0.8a13__py3-none-any.whl → 1.0.9a1__py3-none-any.whl

batFramework/gui/root.py

@@ -70,10 +70,10 @@ class Root(InteractiveWidget):
         return res
 
     def focus_next_tab(self, widget):
-        return True
+        return
 
     def focus_prev_tab(self, widget):
-        return True
+        return
 
     def get_by_uid(self, uid: int) -> "Widget":
         def helper(w: "Widget", uid: int) -> "Widget":
@@ -91,12 +91,9 @@ class Root(InteractiveWidget):
         if not force:
             return self
         self.rect.size = size
-        # self.build(resolve_constraints=True)
         return self
 
     def do_handle_event(self, event):
-        if not self.parent_scene.get_sharedVar("player_has_control"):
-            return
         if self.focused:
             if event.type == pygame.KEYDOWN:
                 if self.focused.on_key_down(event.key):
@@ -130,8 +127,6 @@ class Root(InteractiveWidget):
 
     def update(self, dt: float) -> None:
         super().update(dt)
-        if not self.parent_scene.get_sharedVar("player_has_control",True):
-            return
         old = self.hovered
         transposed = self.drawing_camera.screen_to_world(pygame.mouse.get_pos())
         self.hovered = self.top_at(*transposed) if self.top_at(*transposed) else None
@@ -145,8 +140,6 @@ class Root(InteractiveWidget):
 
     def draw(self, camera: bf.Camera) -> None:
         super().draw(camera)
-        if not self.parent_scene.get_sharedVar("player_has_control"):
-            return
         if (
             self.parent_scene
             and self.parent_scene.active

batFramework/gui/shape.py

@@ -47,6 +47,8 @@ class Shape(Widget):
         self.relief = relief
         return self
 
+
+
     def set_texture(
         self, surface: pygame.SurfaceType, subsize: tuple[int, int] | None = None
     ) -> Self:

batFramework/gui/textInput.py

@@ -58,7 +58,7 @@ class TextInput(Label, InteractiveWidget):
     def __init__(self) -> None:
         self.cursor_position = (0, 0)
         self.old_key_repeat = (0, 0)
-        self.cursor_timer = bf.Timer(0.3, self._cursor_toggle, loop=True).start()
+        self.cursor_timer = bf.Timer(0.2, self._cursor_toggle, loop=True).start()
         self.cursor_timer.pause()
         self.show_cursor = False
         self.on_modify: Callable[[str], str] = None
@@ -110,6 +110,14 @@ class TextInput(Label, InteractiveWidget):
             return None
         return lines[line]
 
+    def get_debug_outlines(self):
+        if self.visible:
+            offset = self._get_outline_offset() if self.show_text_outline else (0,0)
+            yield (self.text_rect.move(self.rect.x - offset[0] - self.scroll.x,self.rect.y - offset[1] - self.scroll.y), "purple")
+        yield from super().get_debug_outlines()
+        yield (self.get_cursor_rect().move(-self.scroll+self.rect.topleft),"green")
+
+
     def set_cursor_position(self, position: tuple[int, int]) -> Self:
         x, y = position
 
@@ -117,12 +125,30 @@ class TextInput(Label, InteractiveWidget):
         y = max(0, min(y, len(lines) - 1))
         line_length = len(lines[y])
         x = max(0, min(x, line_length))
-
-        self.cursor_position = (x, y)
         self.show_cursor = True
-        self.dirty_shape = True
+        self.cursor_position = (x,y)
+        self.dirty_surface = True
+        offset = self._get_outline_offset() if self.show_text_outline else (0,0)
+        padded = self.get_padded_rect().move(-self.rect.x + offset[0], -self.rect.y + offset[1])
+        self.align_text(self.text_rect,padded,self.alignment)
         return self
 
+    def get_cursor_rect(self)->pygame.FRect:
+        if not self.font_object:
+            return pygame.FRect(0,0,0,0)
+
+        lines = self.text.split('\n')
+        line_x, line_y = self.cursor_position
+
+        height = self.font_object.get_point_size()
+
+        cursor_y = self.get_padded_rect().__getattribute__(self.alignment.value)[1] - self.rect.top
+        cursor_y += line_y * height
+        cursor_x = self.text_rect.x
+        cursor_x += self.font_object.size(lines[line_y][:line_x])[0] if line_x > 0 else 0
+        cursor_rect = pygame.Rect(cursor_x, cursor_y, 1, height)
+        return cursor_rect
+
     def cursor_to_absolute(self, position: tuple[int, int]) -> int:
         x, y = position
 
@@ -146,68 +172,72 @@ class TextInput(Label, InteractiveWidget):
         return (len(lines[-1]), len(lines) - 1)
 
     def do_handle_event(self, event):
-        if not self.is_focused:
-            return
-
-        if event.type not in [pygame.TEXTINPUT, pygame.KEYDOWN]:
+        if not self.is_focused or event.type not in [pygame.TEXTINPUT, pygame.KEYDOWN]:
             return
 
         text = self.get_text()
-        current = self.cursor_to_absolute(self.cursor_position)
+        current_pos = self.cursor_to_absolute(self.cursor_position)
+        pressed = pygame.key.get_pressed()
+
         if event.type == pygame.TEXTINPUT:
-            self.set_text(text[:current] + event.text + text[current:])
-            self.set_cursor_position(self.absolute_to_cursor(current + len(event.text)))
+            # Insert text at the current cursor position
+            self.set_text(f"{text[:current_pos]}{event.text}{text[current_pos:]}")
+            self.set_cursor_position(self.absolute_to_cursor(current_pos + len(event.text)))
+
         elif event.type == pygame.KEYDOWN:
-            pressed = pygame.key.get_pressed()
-            if event.key == pygame.K_ESCAPE:
-                self.lose_focus()
-            elif event.key == pygame.K_BACKSPACE:
-                if current > 0:
-                    self.set_text(text[:current - 1] + text[current:])
-                    self.set_cursor_position(self.absolute_to_cursor(current - 1))
-            elif event.key == pygame.K_DELETE:
-                if current < len(text):
-                    self.set_text(text[:current] + text[current + 1:])
-            elif event.key == pygame.K_RIGHT:
-                if self.cursor_to_absolute(self.cursor_position)>=len(self.text):
+            match event.key:
+                case pygame.K_ESCAPE:
+                    self.lose_focus()
+
+                case pygame.K_BACKSPACE if current_pos > 0:
+                    # Remove the character before the cursor
+                    self.set_text(f"{text[:current_pos - 1]}{text[current_pos:]}")
+                    self.set_cursor_position(self.absolute_to_cursor(current_pos - 1))
+
+                case pygame.K_DELETE if current_pos < len(text):
+                    # Remove the character at the cursor
+                    self.set_text(f"{text[:current_pos]}{text[current_pos + 1:]}")
+
+                case pygame.K_RIGHT:
+                    if current_pos < len(text):
+                        self.handle_cursor_movement(pressed, current_pos, direction="right")
+
+                case pygame.K_LEFT:
+                    if current_pos > 0:
+                        self.handle_cursor_movement(pressed, current_pos, direction="left")
+
+                case pygame.K_UP:
+                    # Move cursor up one line
+                    self.set_cursor_position((self.cursor_position[0], self.cursor_position[1] - 1))
+
+                case pygame.K_DOWN:
+                    # Move cursor down one line
+                    self.set_cursor_position((self.cursor_position[0], self.cursor_position[1] + 1))
+
+                case pygame.K_RETURN:
+                    # Insert a newline at the current cursor position
+                    self.set_text(f"{text[:current_pos]}\n{text[current_pos:]}")
+                    self.set_cursor_position(self.absolute_to_cursor(current_pos + 1))
+                case _ :
                     return
-                if self.cursor_position[0] == len(self.get_line(self.cursor_position[1])):
-                    self.set_cursor_position((0, self.cursor_position[1] + 1))
-                else:
-                    if pressed[pygame.K_LCTRL] or pressed[pygame.K_RCTRL]:
-                        index = find_next_word(self.text,current)
-                        if index ==-1 : index = current+1
-                        self.set_cursor_position(self.absolute_to_cursor(index))
-                    else:
-                        self.set_cursor_position(self.absolute_to_cursor(current + 1))
-            elif event.key == pygame.K_LEFT:
-
-
-                if self.cursor_position[0] == 0 and self.cursor_position[1] > 0:
-                    self.set_cursor_position((len(self.get_line(self.cursor_position[1] - 1)), self.cursor_position[1] - 1))
-                else:
-                    if pressed[pygame.K_LCTRL] or pressed[pygame.K_RCTRL]:
-                        index = find_prev_word(self.text,current-1)
-                        if index ==-1 : index = current-1
-                        self.set_cursor_position(self.absolute_to_cursor(index))
-                    else:
-                        self.set_cursor_position(self.absolute_to_cursor(current - 1))
-            elif event.key == pygame.K_UP:
-                x, y = self.cursor_position
-                self.set_cursor_position((x, y - 1))
-            elif event.key == pygame.K_DOWN:
-                x, y = self.cursor_position
-                self.set_cursor_position((x, y + 1))
-            elif event.key == pygame.K_RETURN:
-                self.set_text(text[:current] + '\n' + text[current:])
-                self.set_cursor_position(self.absolute_to_cursor(current + 1))
-            else:
-                return
-        else:
-            return
 
         event.consumed = True
 
+    def handle_cursor_movement(self, pressed, current_pos, direction):
+        if direction == "right":
+            if pressed[pygame.K_LCTRL] or pressed[pygame.K_RCTRL]:
+                next_word_pos = find_next_word(self.text, current_pos)
+                self.set_cursor_position(self.absolute_to_cursor(next_word_pos if next_word_pos != -1 else current_pos + 1))
+            else:
+                self.set_cursor_position(self.absolute_to_cursor(current_pos + 1))
+        elif direction == "left":
+            if pressed[pygame.K_LCTRL] or pressed[pygame.K_RCTRL]:
+                prev_word_pos = find_prev_word(self.text, current_pos - 1)
+                self.set_cursor_position(self.absolute_to_cursor(prev_word_pos if prev_word_pos != -1 else current_pos - 1))
+            else:
+                self.set_cursor_position(self.absolute_to_cursor(current_pos - 1))
+
+
     def set_text(self, text: str) -> Self:
         if self.on_modify:
             text = self.on_modify(text)
@@ -216,32 +246,39 @@ class TextInput(Label, InteractiveWidget):
     def _paint_cursor(self) -> None:
         if not self.font_object or not self.show_cursor:
             return
+        cursor_rect = self.get_cursor_rect()
+        cursor_rect.move_ip(-self.scroll)
 
-        lines = self.text.split('\n')
-        line_x, line_y = self.cursor_position
-
-        cursor_y = self.padding[1] 
-        cursor_y += line_y * self.font_object.get_linesize()
-        cursor_x = self.padding[0]
-        cursor_x += self.font_object.size(lines[line_y][:line_x])[0] if line_x > 0 else 0
+        
+        pygame.draw.rect(self.surface, bf.color.CLOUD, cursor_rect.inflate(2,2))
 
-        cursor_rect = pygame.Rect(cursor_x, cursor_y, 2, self.font_object.get_height())
         pygame.draw.rect(self.surface, self.text_color, cursor_rect)
 
     def paint(self) -> None:
         super().paint()
         self._paint_cursor()
 
-    # def set_alignment(self, alignment: bf.alignment) -> Self:
-    #     return self
-
-    # def align_text(
-    #     self, text_rect: pygame.FRect, area: pygame.FRect, alignment: bf.alignment
-    # ):
-    #     if alignment == bf.alignment.LEFT:
-    #         alignment = bf.alignment.MIDLEFT
-    #     elif alignment == bf.alignment.MIDRIGHT:
-    #         alignment = bf.alignment.MIDRIGHT
-    #     pos = area.__getattribute__(alignment.value)
-    #     text_rect.__setattr__(alignment.value, pos)
-    #     return
+    def align_text(
+        self, text_rect: pygame.FRect, area: pygame.FRect, alignment: bf.alignment
+    ):
+        cursor_rect = self.get_cursor_rect()
+        
+        if alignment == bf.alignment.LEFT:
+            alignment = bf.alignment.MIDLEFT
+        elif alignment == bf.alignment.MIDRIGHT:
+            alignment = bf.alignment.MIDRIGHT
+        pos = area.__getattribute__(alignment.value)
+        text_rect.__setattr__(alignment.value, pos)
+
+        
+        if cursor_rect.right > area.right+self.scroll.x:
+            self.scroll.x=cursor_rect.right - area.right
+        elif cursor_rect.x < self.scroll.x+area.left:
+            self.scroll.x= cursor_rect.left - area.left 
+        self.scroll.x = max(self.scroll.x,0)
+
+        if cursor_rect.bottom > area.bottom + self.scroll.y:
+            self.scroll.y = cursor_rect.bottom - area.bottom
+        elif cursor_rect.y < self.scroll.y + area.top:
+            self.scroll.y = cursor_rect.top - area.top
+        self.scroll.y = max(self.scroll.y, 0)

batFramework/gui/toggle.py

@@ -14,7 +14,6 @@ class Toggle(Button):
         super().__init__(text, callback)
         self.add(self.indicator)
         self.set_clip_children(False)
-        # self.set_gap(int(max(4, self.get_padded_width() / 3)))
 
     def set_visible(self, value: bool) -> Self:
         self.indicator.set_visible(value)
@@ -77,7 +76,6 @@ class Toggle(Button):
             0, 0, self.text_rect.w + gap + self.indicator.rect.w, self.text_rect.h 
         )
 
-
         if self.autoresize_h or self.autoresize_w:
             target_rect = self.inflate_rect_by_padding(joined_rect)
             if not self.autoresize_w:
@@ -86,8 +84,7 @@ class Toggle(Button):
                 target_rect.h = self.rect.h
             if self.rect.size != target_rect.size:
                 self.set_size(target_rect.size)
-                self.build()
-                return
+                self.apply_updates()
 
         # ------------------------------------ size is ok
 

batFramework/gui/widget.py

@@ -11,14 +11,12 @@ MAX_CONSTRAINTS = 10
 
 class WidgetMeta(type):
     def __call__(cls, *args, **kwargs):
-        """Called when you call MyNewClass()"""
         obj = type.__call__(cls, *args, **kwargs)
-        # obj.new_init()
         bf.StyleManager().register_widget(obj)
         return obj
 
 
-class Widget(bf.Entity, metaclass=WidgetMeta):
+class Widget(bf.Drawable, metaclass=WidgetMeta):
     def __init__(self, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
         self.children: list["Widget"] = []
@@ -28,10 +26,9 @@ class Widget(bf.Entity, metaclass=WidgetMeta):
         self.clip_children: bool = True
         self.padding = (0, 0, 0, 0)
         self.dirty_surface: bool = True  #  if true will call paint before drawing
-        self.dirty_shape: bool = (
-            True  #    if true will call (build+paint) before drawing
-        )
-        self.dirty_constraints: bool = False
+        self.dirty_shape: bool = True  #    if true will call (build+paint) before drawing
+        self.dirty_constraints: bool = False # if true will call resolve_constraints
+
         self.is_root: bool = False
         self.autoresize_w, self.autoresize_h = True, True
         self.__constraint_iteration = 0
@@ -221,7 +218,7 @@ class Widget(bf.Entity, metaclass=WidgetMeta):
             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):
@@ -240,6 +237,7 @@ class Widget(bf.Entity, metaclass=WidgetMeta):
                 for c in constraints:
                     if c in self.__constraints_to_ignore:continue
                     if not c.evaluate(self.parent,self) :
+                        # print(c," is applied")
                         c.apply(self.parent,self)
             # second pass where we check conflicts
             for c in constraints:
@@ -256,9 +254,10 @@ class Widget(bf.Entity, metaclass=WidgetMeta):
 
         if self.__constraints_to_ignore:
             print("Constraints ignored : ",[str(c) for c in self.__constraints_to_ignore])
-        
-
+            
         self.dirty_constraints = False
+        # print(self,self.uid,"resolve constraints : Success")
+
 
     def has_constraint(self, name: str) -> bool:
         return any(c.name == name for c in self.constraints)
@@ -313,17 +312,16 @@ class Widget(bf.Entity, metaclass=WidgetMeta):
             size[0] = self.rect.w
         if size[1] is None:
             size[1] = self.rect.h
-        if size == self.rect.size:
+        if (int(size[0]),int(size[1])) == (int(self.rect.w),int(self.rect.h)):
             return self
         self.rect.size = size
         self.dirty_shape = True
         return self
 
-    def process_event(self, event: pygame.Event) -> bool:
+    def process_event(self, event: pygame.Event) -> None:
         # First propagate to children
         for child in self.children:
             child.process_event(event)
-        # return True if the method is blocking (no propagation to next children of the scene)
         super().process_event(event)
 
     def update(self, dt) -> None:
@@ -351,7 +349,7 @@ class Widget(bf.Entity, metaclass=WidgetMeta):
         if top_down:
             func(self, *args, **kwargs)
         for child in self.children:
-            child.visit(func, top_down)
+            child.visit(func, top_down,*args,**kwargs)
         if not top_down:
             func(self, *args, **kwargs)
 
@@ -361,55 +359,69 @@ class Widget(bf.Entity, metaclass=WidgetMeta):
         if self.parent:
             self.parent.visit_up(func, *args, **kwargs)
 
-    def selective_up(self, widget: "Widget"):
-        # if returns True then stop climbing widget tree
-        if widget.parent and widget.parent.dirty_constraints:
-            return False
-        widget.visit(self.selective_down)
-        return True
+    """
+    1 : 
+    bottom up -> only build children
 
-    def selective_down(self, widget: "Widget"):
-        if widget.constraints:
-            widget.resolve_constraints()
-        else:
-            widget.dirty_constraints = False
+    """
+    def update_children_size(self, widget: "Widget"):
+        # print(widget,widget.uid,"constraints resolve in update size func")
+
+        widget.resolve_constraints()
         if widget.dirty_shape:
+            # print(widget,widget.uid,"build in update size func")
             widget.build()
             widget.dirty_shape = False
-            self.dirty_surface = True
+            widget.dirty_surface = True
+
+    def find_highest_dirty_constraints_widget(self) -> "Widget":
+        w = self
+        tmp = w
+        while not tmp.is_root:
+            if tmp.dirty_constraints or tmp.dirty_shape:
+                w = tmp
+            if not tmp.parent:
+                break
+            tmp = tmp.parent
+        return w
 
-    def draw(self, camera: bf.Camera) -> None:
+
+    def apply_updates(self) -> None:
+        # Step 1: Build shape if needed
         if self.dirty_shape:
-            self.dirty_constraints = True
-            self.dirty_surface = True
-            self.build()
+            self.build()  # Finalize widget size
             self.dirty_shape = False
+            self.dirty_surface = True
+            # Propagate dirty_constraints to children in case size affects their position
             for child in self.children:
                 child.dirty_constraints = True
 
+        # Step 2: Resolve constraints now that size is finalized
         if self.dirty_constraints:
-            if self.parent and self.parent.dirty_constraints:
-                self.parent.visit_up(self.selective_up)
-            else:
-                self.visit(lambda c: c.resolve_constraints())
+            self.resolve_constraints()  # Finalize positioning based on final size
+            self.dirty_constraints = False
 
+        # Step 3: Paint the surface if flagged as dirty
         if self.dirty_surface:
             self.paint()
             self.dirty_surface = False
+    
 
+
+    def draw(self, camera: bf.Camera) -> None:
+        self.apply_updates()
+        # Draw widget and handle clipping if necessary
         super().draw(camera)
 
         if self.clip_children:
-
             new_clip = camera.world_to_screen(self.get_padded_rect())
             old_clip = camera.surface.get_clip()
             new_clip = new_clip.clip(old_clip)
             camera.surface.set_clip(new_clip)
 
-        _ = [
+        # Draw each child widget, sorted by render order
+        for child in sorted(self.children, key=lambda c: c.render_order):
             child.draw(camera)
-            for child in sorted(self.children, key=lambda c: c.render_order)
-        ]
 
         if self.clip_children:
             camera.surface.set_clip(old_clip)

batFramework/manager.py

@@ -1,23 +1,25 @@
 import batFramework as bf
 import pygame
 import asyncio
-import random
 
 class Manager(bf.SceneManager):
     def __init__(self, *initial_scene_list) -> None:
-        # random.seed("random")
         super().__init__()
-        self._screen: pygame.Surface | None = bf.const.SCREEN
-        self._timeManager = bf.TimeManager()
-        self._cutsceneManager = bf.CutsceneManager()
-        self._cutsceneManager.set_manager(self)
-        self._clock: pygame.Clock = pygame.Clock()
-        self._is_async_running : bool = False
-        self._running = False
+        self.debug_mode: bf.enums.debugMode = bf.debugMode.HIDDEN
+        self.screen: pygame.Surface | None = bf.const.SCREEN
+        self.timeManager = bf.TimeManager()
+        self.cutsceneManager = bf.CutsceneManager()
+        self.cutsceneManager.set_manager(self)
+        self.clock: pygame.Clock = pygame.Clock()
+        self.is_async_running : bool = False
+        self.running = False
         pygame.mouse.set_cursor(bf.const.DEFAULT_CURSOR)
+        bf.ResourceManager().set_sharedVar("clock", self.clock)
+        bf.ResourceManager().set_sharedVar("debug_mode", self.debug_mode)
+        
         self.do_pre_init()
-        self.init_scenes(*initial_scene_list)
-        self.set_sharedVar("clock", self._clock)
+        if initial_scene_list:
+            self.init_scenes(*initial_scene_list)
         self.do_init()
 
     @staticmethod
@@ -39,14 +41,14 @@ class Manager(bf.SceneManager):
         print("=" * 50)
         
         # Print the timers information
-        print(self._timeManager)
+        print(self.timeManager)
         
         # End with a visual separator
         print("=" * 50 + "\n")
 
 
     def get_fps(self) -> float:
-        return self._clock.get_fps()
+        return self.clock.get_fps()
 
     def do_init(self) -> None:
         pass
@@ -55,67 +57,77 @@ class Manager(bf.SceneManager):
         pass
 
     def stop(self) -> None:
-        self._running = False
+        self.running = False
+
+    def process_event(self, event: pygame.Event):
+        event.consumed = False
+        keys = pygame.key.get_pressed()
+        if (
+            bf.const.ALLOW_DEBUG and
+            keys[pygame.K_LCTRL]
+            and keys[pygame.K_LSHIFT]
+            and event.type == pygame.KEYDOWN
+        ):
+            if event.key == pygame.K_d:
+                self.cycle_debug_mode()
+                return
+            if event.key == pygame.K_p:
+                self.print_status()
+                return
+        super().process_event(event)
+        if not event.consumed:
+            if event.type == pygame.QUIT:
+                self.running = False
+            elif event.type == pygame.VIDEORESIZE and not (
+                bf.const.FLAGS & pygame.SCALED
+            ):
+                bf.const.set_resolution((event.w, event.h))
+
+    def update(self, dt: float) -> None:
+        self.timeManager.update(dt)
+        self.cutsceneManager.update(dt)
+        super().update(dt)
+
 
     async def run_async(self):
-        if self._running:
-            print("Error : Already running")
+        if len(self.scenes) == 0:
+            raise Exception("Manager can't start without scenes")
+        if self.running:
+            raise Exception("Error : Already running")
             return
-        self._is_async_running = True
-        self._running = True
+        self.is_async_running = True
+        self.running = True
         dt: float = 0
-        while self._running:
+        while self.running:
             for event in pygame.event.get():
-                event.consumed = False
                 self.process_event(event)
-                if not event.consumed:
-                    if event.type == pygame.QUIT:
-                        self._running = False
-                        break
-                    if event.type == pygame.VIDEORESIZE and not (
-                        bf.const.FLAGS & pygame.SCALED
-                    ):
-                        bf.const.set_resolution((event.w, event.h))
             # update
-            self._timeManager.update(dt)
-            self._cutsceneManager.update(dt)
             self.update(dt)
             # render
-            self._screen.fill((0, 0, 0))
-            self.draw(self._screen)
+            self.draw(self.screen)
             pygame.display.flip()
-            dt = self._clock.tick(bf.const.FPS) / 1000
-            # dt = min(dt, 0.02) dirty fix for dt being too high when window not focused for a long time
+            dt = self.clock.tick(bf.const.FPS) / 1000
+            dt = min(dt, 0.02) # dirty fix for dt being too high when window not focused for a long time
             await asyncio.sleep(0)
         pygame.quit()
 
 
     def run(self) -> None:
-        if self._running:
-            print("Error : Already running")
+        if len(self.scenes) == 0:
+            raise Exception("Manager can't start without scenes")
+        if self.running:
+            raise Exception("Error : Already running")
             return
-        self._running = True
+        self.running = True
         dt: float = 0
-        while self._running:
+        while self.running:
             for event in pygame.event.get():
-                event.consumed = False
                 self.process_event(event)
-                if not event.consumed:
-                    if event.type == pygame.QUIT:
-                        self._running = False
-                        break
-                    if event.type == pygame.VIDEORESIZE and not (
-                        bf.const.FLAGS & pygame.SCALED
-                    ):
-                        bf.const.set_resolution((event.w, event.h))
             # update
-            self._timeManager.update(dt)
-            self._cutsceneManager.update(dt)
             self.update(dt)
             # render
-            self._screen.fill((0, 0, 0))
-            self.draw(self._screen)
+            self.draw(self.screen)
             pygame.display.flip()
-            dt = self._clock.tick(bf.const.FPS) / 1000
-            # dt = min(dt, 0.02) dirty fix for dt being too high when window not focused for a long time
+            dt = self.clock.tick(bf.const.FPS) / 1000
+            dt = min(dt, 0.02) # dirty fix for dt being too high when window not focused for a long time
         pygame.quit()