e2D 1.4.19__py3-none-any.whl → 1.4.23__py3-none-any.whl

e2D/colors.py

@@ -1,7 +1,8 @@
+from __future__ import annotations
 from colorsys import hsv_to_rgb as __hsv_to_rgb_def__, hls_to_rgb as __hls_to_rgb_def__, rgb_to_hls as __rgb_to_hls__, rgb_to_hsv as __rgb_to_hsv__
 from typing import Any, Callable, Generator, Literal
 from pygame.color import Color as __color_pygame__
-from random import randint as __randint__
+from random import random as __rand__
 
 RGB_COLOR_MODE = "rgb"
 RGBA_COLOR_MODE = "rgba"
@@ -15,11 +16,11 @@ HLS_COLOR_MODE = "hls"
 
 __LITERAL_COLOR_MODES__ = Literal["rgb","rgba","bgr","bgra","g","hsv","hls"] #,"cmyk","lab"]
 
-def __hsv_to_rgb__(h:int|float, s:int|float, v:int|float) -> tuple[int|float, int|float, int|float]:
+def __hsv_to_rgb__(h:"int|float", s:"int|float", v:"int|float") -> tuple["int|float", "int|float", "int|float"]:
     r,g,b = __hsv_to_rgb_def__(h, s, v)
     return r*255, g*255, b*255
 
-def __hls_to_rgb__(h:int|float, s:int|float, v:int|float) -> tuple[int|float, int|float, int|float]:
+def __hls_to_rgb__(h:"int|float", s:"int|float", v:"int|float") -> tuple["int|float", "int|float", "int|float"]:
     r,g,b = __hls_to_rgb_def__(h, s, v)
     return r*255, g*255, b*255
     
@@ -82,6 +83,12 @@ __conversion_table__ :dict[__LITERAL_COLOR_MODES__, dict[__LITERAL_COLOR_MODES__
         },
 }
 
+def pygamize_color(color: "__color_pygame__|Color") -> "__color_pygame__":
+    return color() if isinstance(color, Color) else color
+
+def unpygamize_color(color: "__color_pygame__|Color") -> "Color":
+    return Color(*color[:], mode=RGBA_COLOR_MODE) if isinstance(color, __color_pygame__) else color
+
 class Color:
     def __init__(self, *values, mode:__LITERAL_COLOR_MODES__=RGB_COLOR_MODE) -> None:
         self.__dict__ = dict(zip(mode, values))
@@ -104,35 +111,35 @@ class Color:
         return (d ** .5) if rooted else d
     
     @classmethod
-    def new_rgb(cls, r:int|float, g:int|float, b:int|float) -> "Color":
+    def new_rgb(cls, r:"int|float", g:"int|float", b:"int|float") -> "Color":
         return Color(r,g,b, mode=RGB_COLOR_MODE)
     @classmethod
-    def new_rgba(cls, r:int|float, g:int|float, b:int|float, a:int|float) -> "Color":
+    def new_rgba(cls, r:"int|float", g:"int|float", b:"int|float", a:"int|float") -> "Color":
         return Color(r,g,b,a, mode=RGBA_COLOR_MODE)
     @classmethod
-    def new_bgr(cls, b:int|float, g:int|float, r:int|float) -> "Color":
+    def new_bgr(cls, b:"int|float", g:"int|float", r:"int|float") -> "Color":
         return Color(b,g,r, mode=BGR_COLOR_MODE)
     @classmethod
-    def new_bgra(cls, b:int|float, g:int|float, r:int|float, a:int|float) -> "Color":
+    def new_bgra(cls, b:"int|float", g:"int|float", r:"int|float", a:"int|float") -> "Color":
         return Color(b,g,r,a, mode=BGRA_COLOR_MODE)
     @classmethod
     def new_g(cls, g) -> "Color":
         return Color(g, mode=GRAY_COLOR_MODE)
     @classmethod
-    def new_hsv(cls, h:int|float, s:int|float, v:int|float) -> "Color":
+    def new_hsv(cls, h:"int|float", s:"int|float", v:"int|float") -> "Color":
         return Color(h,s,v, mode=HSV_COLOR_MODE)
     @classmethod
-    def new_hls(cls, h:int|float, l:int|float, s:int|float) -> "Color":
+    def new_hls(cls, h:"int|float", l:"int|float", s:"int|float") -> "Color":
         return Color(h,l,s, mode=HLS_COLOR_MODE)
     # @classmethod
-    # def new_cmyk(cls, c:int|float, m:int|float, y:int|float, k:int|float) -> Color:
+    # def new_cmyk(cls, c:"int|float", m:"int|float", y:"int|float", k:"int|float") -> Color:
     #     return Color(c,m,y,k, mode=CMYK_COLOR_MODE)
     # @classmethod
-    # def new_lab(cls, l:int|float, a:int|float, b:int|float) -> Color:
+    # def new_lab(cls, l:"int|float", a:"int|float", b:"int|float") -> Color:
     #     return Color(l,a,b, mode=LAB_COLOR_MODE)
 
     @property
-    def values(self) -> tuple[int|float, ...]:
+    def values(self) -> tuple["int|float", ...]:
         return tuple(self.__dict__.values())[:-1]
 
     @property
@@ -140,7 +147,7 @@ class Color:
         return tuple(self.__dict__.keys())[:-1]
     
     @property
-    def items(self) -> tuple[tuple[str, int|float], ...]:
+    def items(self) -> tuple[tuple[str, "int|float"], ...]:
         return tuple(self.__dict__.items())[:-1]
 
     def copy(self) -> "Color":
@@ -179,7 +186,7 @@ class Color:
         return "Color(" + ", ".join(f"{k}:{v}" for k, v in self.items) + ")"
 
     def __call__(self) -> __color_pygame__:
-        return __color_pygame__(int(self.r), int(self.g), int(self.b))
+        return __color_pygame__(int(self.r), int(self.g), int(self.b)) if self.mode == RGB_COLOR_MODE else __color_pygame__(int(self.r), int(self.g), int(self.b), int(self.a))
     
     # fast operations     Vector2D.operation(both,x,y)
     def add(self, all3=.0, r=.0, g=.0, b=.0) -> "Color":
@@ -386,7 +393,7 @@ class Color:
     def __float__(self) -> "Color":
         return Color(float(self.r), float(self.g), float(self.b))
 
-    def __getitem__(self, n) -> int|float:
+    def __getitem__(self, n) -> "int|float":
         return self.values[n] if isinstance(n, int) else self.values[self.keys.index(n)]
     
     def __iter__(self) -> Generator[float, Any, None]:
@@ -406,8 +413,10 @@ class Color:
         try:
             return cls(*other.values, mode=other.mode)
         except:
-            raise TypeError(f"The value {other} of type {type(other)} is not a num type: [{int|float}] nor an array type: [{list|tuple}]")
+            raise TypeError(f"The value {other} of type {type(other)} is not a num type: [int|float] nor an array type: [list|tuple]")
     
+    @classmethod
+    def transparent(cls) -> "Color": return Color(0,0,0,0, mode=RGBA_COLOR_MODE)
     @classmethod
     def white(cls) -> "Color": return Color(255,255,255)
     @classmethod
@@ -418,23 +427,44 @@ class Color:
     def green(cls) -> "Color": return Color(0,255,0)
     @classmethod
     def blue(cls) -> "Color": return Color(0,0,255)
-    
-    # @classmethod
-    # def (cls) -> "Color": return Color(0,0,255)
-
     @classmethod
-    def randomize(cls) -> "Color":
-        return Color(__randint__(0,255), __randint__(0,255), __randint__(0,255))
-
+    def cyan(cls) -> "Color": return Color(0,255,255)
+    @classmethod
+    def magenta(cls) -> "Color": return Color(255,0,255)
+    @classmethod
+    def yellow(cls) -> "Color": return Color(255,255,0)
 
+    @classmethod
+    def randomize(cls, start=0, end=255, func=lambda val:val) -> "Color":
+        if not isinstance(start, Color):
+            if isinstance(start, (int, float)):
+                start = Color(start, start, start)
+            else:
+                raise Exception(f"\nArg start must be in [Color, int, float, tuple, list] not a [{type(start)}]\n")
+        if not isinstance(end, Color):
+            if isinstance(end, (int, float)):
+                end = Color(end, end, end)
+            else:
+                raise Exception(f"\nArg end must be in [Color, int, float, tuple, list] not a [{type(end)}]\n")
+        return start + Color(func(__rand__()), func(__rand__()), func(__rand__())) * (end - start)
+
+
+TRANSPARENT_COLOR = Color.transparent()
 WHITE_COLOR = Color.white()
 BLACK_COLOR = Color.black()
 RED_COLOR = Color.red()
 GREEN_COLOR = Color.green()
 BLUE_COLOR = Color.blue()
+CYAN_COLOR = Color.cyan()
+MAGENTA_COLOR = Color.magenta()
+YELLOW_COLOR = Color.yellow()
 
+TRANSPARENT_COLOR_PYG = TRANSPARENT_COLOR() 
 WHITE_COLOR_PYG = WHITE_COLOR()
 BLACK_COLOR_PYG = BLACK_COLOR()
 RED_COLOR_PYG = RED_COLOR()
 GREEN_COLOR_PYG = GREEN_COLOR()
 BLUE_COLOR_PYG = BLUE_COLOR()
+CYAN_COLOR_PYG = CYAN_COLOR()
+MAGENTA_COLOR_PYG = MAGENTA_COLOR()
+YELLOW_COLOR_PYG = YELLOW_COLOR()

e2D/envs.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-from typing import Literal
+from typing import Literal, Optional
 
 from .utils import *
 import pygame as pg
@@ -42,13 +42,15 @@ class RootEnv:
                  quit_on_key_pressed : None|int = pg.K_x,
                  vsync : bool = True,
                  window_flags : int = pg.DOUBLEBUF,
+                 display_index : int = 0,
                  clear_screen_each_frame : bool = True) -> None:
         self.quit = False
         self.__screen_size__ :Vector2D= screen_size
 
         self.__vsync__ = vsync
         self.__flags__ = window_flags
-        self.screen = pg.display.set_mode(self.__screen_size__(), vsync=self.__vsync__, flags=self.__flags__)
+        self.__display_index__ = display_index
+        self.screen = pg.display.set_mode(self.__screen_size__(), vsync=self.__vsync__, flags=self.__flags__, display=self.__display_index__)
 
         self.clock = pg.time.Clock()
         self.keyboard = Keyboard()
@@ -56,15 +58,38 @@ class RootEnv:
 
         self.target_fps = target_fps
         self.current_fps = self.target_fps if self.target_fps != 0 else 1
+        self.__dt__ = 1 / self.current_fps
         self.current_frame = 0
         self.show_fps = show_fps
         self.events :list[pg.event.Event]= []
-        self.background_color = BLACK_COLOR_PYG
+        
+        # Track start time for accurate runtime calculation (excluding compilation time)
+        self.set_starting_timer()
+        
+        self.__background_color__ :pg.Color= BLACK_COLOR_PYG
+        
         self.clear_screen_each_frame = clear_screen_each_frame
         self.utils :dict[int|str, Util]= {}
         self.selected_util :Util|None = None
         self.__quit_on_key_pressed__ = quit_on_key_pressed
 
+        self.fps_label = Label(str(round(self.current_fps,2)), self.screen_size * .01, V2(250, 50), BLACK_COLOR_PYG, TRANSPARENT_COLOR_PYG, WHITE_COLOR_PYG, border_width=0, starting_hidden=(not self.show_fps), pivot_position="top_left", font=FONT_ARIAL_32)
+        self.add_utils(self.fps_label)
+
+    def set_starting_timer(self) -> None:
+        self.__start_time__ = pg.time.get_ticks()
+
+    def init_rec(self, fps:int=30, draw_on_screen:bool=True, path:str='output.mp4', font:pg.font.Font=FONT_MONOSPACE_16) -> None:
+        from .winrec import WinRec
+        self.__winrecorder__ = WinRec(self, fps=fps, draw_on_screen=draw_on_screen, path=path, font=font)
+
+    @property
+    def background_color(self) -> Color:
+        return unpygamize_color(self.__background_color__)
+    @background_color.setter
+    def background_color(self, color: Color|pg.Color) -> None:
+        self.__background_color__ = pygamize_color(color)
+    
     @property
     def screen_size(self) -> Vector2D:
         return self.__screen_size__
@@ -72,97 +97,127 @@ class RootEnv:
     @screen_size.setter
     def screen_size(self, new_size:Vector2D) -> None:
         self.__screen_size__ = new_size
-        self.screen = pg.display.set_mode(self.__screen_size__(), vsync=self.__vsync__, flags=self.__flags__)
+        self.screen = pg.display.set_mode(self.__screen_size__(), vsync=self.__vsync__, flags=self.__flags__, display=self.__display_index__)
+
+    def update_screen_to_new_size(self) -> None:
+        self.screen = pg.display.set_mode(self.__screen_size__(), vsync=self.__vsync__, flags=self.__flags__, display=self.__display_index__)
 
     @property
-    def delta(self) -> int:
-        return self.clock.get_time() / 1000
+    def delta(self) -> float:
+        return self.__dt__
 
     def get_teoric_max_fps(self) -> float:
         rawdelta = self.clock.get_rawtime()
         return (1000 / rawdelta) if rawdelta != 0 else 1
 
-    def update_screen_mode(self, vsync:None|bool=None, flags=None) -> None:
-        self.__vsync__ = vsync
-        self.__flags__ = flags
+    def update_screen_mode(self, vsync:Optional[bool]=None, flags:Optional[int]=None, display_index:Optional[int]=None) -> None:
+        if vsync is not None: self.__vsync__ = vsync
+        if flags is not None: self.__flags__ = flags
+        if display_index is not None: self.__display_index__ = display_index
+        self.screen = pg.display.set_mode(self.__screen_size__(), vsync=self.__vsync__, flags=self.__flags__, display=self.__display_index__)
 
     def sleep(self, seconds:int|float, precise_delay=False) -> None:
         if precise_delay:
-            pg.time.delay(seconds * 1000)
+            pg.time.delay(int(seconds * 1000))
         else:
-            pg.time.wait(seconds * 1000)
+            pg.time.wait(int(seconds * 1000))
 
     def add_utils(self, *utils:Util) -> None:
         for util in utils:
             if util.surface == None: util.surface = self.screen
             util.rootEnv = self
+            util.id = self.__new_util_id__()
+            util.__render__()
             self.utils[util.id] = util
 
     def remove_utils(self, *utils:int|str|Util) -> None:
         for uid in utils:
-            if uid in self.utils:
-                del self.utils[uid]
-            elif isinstance(uid, Util):
+            if isinstance(uid, Util):
                 del self.utils[uid.id]
+            elif uid in self.utils:
+                del self.utils[uid]
             else:
                 raise Exception(f"Unknown util type: {uid}")
+    
+    def __new_util_id__(self) -> int:
+        if not self.utils: return 0
+        else: return len(self.utils.keys()) + 1
+
+    def get_util(self, uid:int|str) -> Util|None:
+        if isinstance(uid, Util):
+            return self.utils.get(uid.id)
+        elif isinstance(uid, int) or isinstance(uid, str):
+            return self.utils.get(uid)
+        else:
+            raise Exception(f"Unknown util type: {uid}")
 
     @property
     def runtime_seconds(self) -> float:
-        return pg.time.get_ticks() / 1e3
+        return (pg.time.get_ticks() - self.__start_time__) / 1e3
 
     def init(self, sub_env:DefEnv) -> None:
         self.env = sub_env
 
     def clear(self) -> None:
-        self.screen.fill(self.background_color)
+        self.screen.fill(self.__background_color__)
 
     def clear_rect(self, position:Vector2D, size:Vector2D) -> None:
-        self.screen.fill(self.background_color, position() + size())
+        self.screen.fill(self.__background_color__, position() + size())
 
     def print(self, 
-            text : str, 
-            position : Vector2D, 
-            color : pg.color.Color = WHITE_COLOR_PYG,
-            pivot_position : __LITERAL_PIVOT_POSITIONS__ = "top_left",
-            font : pg.font.Font = FONT_ARIAL_32,
-            bg_color : None|pg.color.Color = None,
-            border_color : pg.color.Color = WHITE_COLOR_PYG,
-            border_width : float = 0.0,
-            border_radius : int|list[int]|tuple[int,int,int,int] = -1,
-            margin : Vector2D = Vector2D.zero(),
-            personalized_surface : pg.Surface|None = None
-            ) -> None:
+              text : str, 
+              position : Vector2D, 
+              color : pg.color.Color = WHITE_COLOR_PYG,
+              pivot_position : __LITERAL_PIVOT_POSITIONS__ = "top_left",
+              font : pg.font.Font = FONT_ARIAL_32,
+              bg_color : None|pg.color.Color = None,
+              border_color : pg.color.Color = WHITE_COLOR_PYG,
+              border_width : float = 0.0,
+              border_radius : int|list[int]|tuple[int,int,int,int] = -1,
+              margin : Vector2D = Vector2D.zero(),
+              personalized_surface : pg.Surface|None = None
+            ) -> Vector2D:
+
         text_box = font.render(text, True, color)
         size = Vector2D(*text_box.get_size()) + margin * 2
         pivotted_position = position - size * __PIVOT_POSITIONS_MULTIPLIER__[pivot_position] + margin
-        if not any(isinstance(border_radius, cls) for cls in {tuple, list}): border_radius = [border_radius]*4
+        if not any(isinstance(border_radius, cls) for cls in {tuple, list}): border_radius = [border_radius] * 4
         surface = (self.screen if personalized_surface == None else personalized_surface)
         if bg_color != None:
             pg.draw.rect(surface, bg_color, (pivotted_position - margin)() + size(), 0, -1, *border_radius)
         if border_width:
             pg.draw.rect(surface, border_color, (pivotted_position - margin)() + size(), border_width, -1, *border_radius)
         surface.blit(text_box, pivotted_position())
+        return size
 
     def __draw__(self) -> None:
-        self.clock.tick(self.target_fps)
+        self.__dt__ = self.clock.tick(self.target_fps) / 1000.0
         self.current_fps = self.clock.get_fps()
+        self.fps_label.text = str(round(self.current_fps, 2))
+
         if self.clear_screen_each_frame: self.clear()
 
         self.env.draw()
-        for util in self.utils.values(): util.draw()
+        for util in self.utils.values(): util.__draw__()
+
+        # Save frame first (clean), then draw info overlay (not saved)
+        if hasattr(self, "__winrecorder__"):
+            self.__winrecorder__.update()  # Captures frame without stats
+            self.__winrecorder__.draw()     # Draws stats on screen only
 
-        if self.show_fps: self.print(str(round(self.current_fps,2)), self.screen_size * .01, bg_color=BLACK_COLOR_PYG)
         pg.display.flip()
 
     def __update__(self) -> None:
         self.mouse.update()
         self.keyboard.update()
         self.env.update()
-        for util in self.utils.values(): util.update()
+        for util in self.utils.values(): util.__update__()
 
     def frame(self) -> None:
-        self.events = pg.event.get()
+        try:
+            self.events = pg.event.get()
+        except SystemError:
+            raise Warning(f"Pygame error with event drivers. Try restarting the program. If the error persists, try restarting your computer.")
         self.current_frame += 1
         self.__update__()
         self.__draw__()
@@ -170,4 +225,5 @@ class RootEnv:
         for event in self.events:
             if event.type == pg.QUIT or ((event.type == pg.KEYDOWN and event.key == self.__quit_on_key_pressed__ and self.selected_util == None) if self.__quit_on_key_pressed__ != None else False):
                 pg.quit()
+                if hasattr(self, "__winrecorder__"): self.__winrecorder__.quit()
                 self.quit = True