e2D 1.4.20__tar.gz → 1.4.21__tar.gz

{e2d-1.4.20 → e2d-1.4.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: e2D
-Version: 1.4.20
+Version: 1.4.21
 Summary: Python library for 2D games. Streamlines dev with keyboard/mouse input, vector calculations, color manipulation, and collision detection. Simplify game creation and unleash creativity!
 Home-page: https://github.com/marick-py/e2D
 Author: Riccardo Mariani

{e2d-1.4.20 → e2d-1.4.21}/e2D/__init__.py

@@ -35,6 +35,22 @@ class Vector2D:
     @angle.setter
     def angle(self, new_angle) -> None:
         self.rotate(new_angle - self.angle)
+    
+    @property
+    def aspect_x(self) -> float:
+        return self.x / self.y if self.y != 0 else 0
+
+    @aspect_x.setter
+    def aspect_x(self, new_aspect) -> None:
+        self.x = self.y * new_aspect
+
+    @property
+    def aspect_y(self) -> float:
+        return self.y / self.x if self.x != 0 else 0
+
+    @aspect_y.setter
+    def aspect_y(self, new_aspect) -> None:
+        self.y = self.x * new_aspect
 
     @property
     def copy(self) -> "Vector2D":
@@ -52,7 +68,7 @@ class Vector2D:
         self.y = clamp(self.y, min_val.y, max_val.y)
 
     @property
-    def normalize(self) -> "Vector2D":
+    def normalized(self) -> "Vector2D":
         if (mag:=self.length) == 0:
             return self.copy
         return Vector2D(self.x / mag, self.y / mag)
@@ -60,11 +76,31 @@ class Vector2D:
     @property
     def length(self) -> float:
         return (self.x ** 2 + self.y ** 2) ** .5
-    
+
+    @length.setter
+    def length(self, new_length: float) -> None:
+        current_length = self.length
+        if current_length == 0:
+            self.x = new_length
+            self.y = 0
+        else:
+            self.x *= new_length / current_length
+            self.y *= new_length / current_length
+
     @property
     def length_sqrd(self) -> float:
         return self.x ** 2 + self.y ** 2
-    
+
+    @length_sqrd.setter
+    def length_sqrd(self, new_length_sqrd: float) -> None:
+        current_length = self.length
+        if current_length == 0:
+            self.x = _mt.sqrt(new_length_sqrd)
+            self.y = 0
+        else:
+            self.x *= _mt.sqrt(new_length_sqrd) / current_length
+            self.y *= _mt.sqrt(new_length_sqrd) / current_length
+
     @property
     def inverse(self) -> "Vector2D":
         return self.mult(-1)
@@ -119,6 +155,13 @@ class Vector2D:
     def complex_to_cartesian(cls, complex_n) -> "Vector2D":
         return cls(complex_n.real, complex_n.imag)
 
+    def cartesian_to_linear(self, size) -> int:
+        return int(self.x + self.y * size)
+
+    @classmethod
+    def linear_to_cartesian(cls, linear, size) -> "Vector2D":
+        return cls(linear % size, linear // size)
+
     def lerp(self, other, t=.1) -> "Vector2D":
         return Vector2D(self.x + (other.x - self.x) * t, self.y + (other.y - self.y) * t)
 
@@ -495,10 +538,10 @@ V2down_right = Vector2D(1, -1)
 V2up_left = Vector2D(-1, 1)
 V2down_left = Vector2D(-1, -1)
 
-V2up_right_norm = V2up_right.normalize
-V2down_right_norm = V2down_right.normalize
-V2up_left_norm = V2up_left.normalize
-V2down_left_norm = V2down_left.normalize
+V2up_right_norm = V2up_right.normalized
+V2down_right_norm = V2down_right.normalized
+V2up_left_norm = V2up_left.normalized
+V2down_left_norm = V2down_left.normalized
 
 VECTORS_4_DIRECTIONS = (V2right, V2down, V2left, V2up)
 VECTORS_4_SEMIDIRECTIONS = (V2down_right, V2down_left, V2up_left, V2up_right)

{e2d-1.4.20 → e2d-1.4.21}/e2D/__init__.pyi

@@ -141,10 +141,59 @@ class Vector2D:
         ...
 
     @property
-    def angle(self:"Vector2D") -> int|float: ...
+    def angle(self:"Vector2D") -> int|float:
+        """
+        # Vector Angle
+        ## Returns:
+            float: The angle (in radians) of the vector from the positive x-axis.
+        ## Example:
+            v = Vector2D(1, 1)
+            angle = v.angle
+            print(angle)  # Output: 0.7853981633974483
+        ## Explanation:
+            This property calculates the angle of the vector from the positive x-axis using the `atan2` function.
+        """
+        ...
 
     @angle.setter
-    def angle(self:"Vector2D", argv) -> None: ...
+    def angle(self:"Vector2D", argv) -> None:
+        ...
+
+    @property
+    def aspect_x(self: "Vector2D") -> float:
+        """
+        # Aspect Ratio (X over Y)
+        ## Returns:
+            float: The aspect ratio of the vector, calculated as the x component divided by the y component. Returns 0 if the y component is zero.
+        ## Example:
+            v = Vector2D(4, 2)
+            aspect = v.aspect_x
+            print(aspect)  # Output: 2.0
+        ## Explanation:
+            This property computes the ratio of the x component to the y component of the vector. If the y component is zero, it returns 0 to avoid division by zero.
+        """
+        ...
+
+    @aspect_x.setter
+    def aspect_x(self: "Vector2D", new_aspect) -> None: ...
+
+    @property
+    def aspect_y(self: "Vector2D") -> float:
+        """
+        # Aspect Ratio (Y over X)
+        ## Returns:
+            float: The aspect ratio of the vector, calculated as the y component divided by the x component. Returns 0 if the x component is zero.
+        ## Example:
+            v = Vector2D(2, 4)
+            aspect = v.aspect_y
+            print(aspect)  # Output: 2.0
+        ## Explanation:
+            This property computes the ratio of the y component to the x component of the vector. If the x component is zero, it returns 0 to avoid division by zero.
+        """
+        ...
+
+    @aspect_y.setter
+    def aspect_y(self: "Vector2D", new_aspect) -> None: ...
 
     @property
     def copy(self:"Vector2D") -> "Vector2D":
@@ -261,7 +310,7 @@ class Vector2D:
         ...
     
     @property
-    def normalize(self:"Vector2D") -> "Vector2D":
+    def normalized(self:"Vector2D") -> "Vector2D":
         """
         # Vector Normalization
 
@@ -273,7 +322,7 @@ class Vector2D:
 
         ## Example:
             v = Vector2D(3, 4)
-            normalized_v = v.normalize()  # Normalize the vector (3, 4)
+            normalized_v = v.normalized()  # Normalize the vector (3, 4)
             print(normalized_v)  # Output: (0.6, 0.8)
 
         ## Explanation:
@@ -293,23 +342,123 @@ class Vector2D:
     
     @property
     def length(self:"Vector2D") -> float:
+        """
+        # Vector Length
+
+        ## Returns:
+            float: The length (magnitude) of the vector.
+
+        ## Example:
+            v = Vector2D(3, 4)
+            length = v.length
+            print(length)  # Output: 5.0
+
+        ## Explanation:
+            This property calculates the length (magnitude) of the vector using the Pythagorean theorem.
+        """
         ...
 
     @property
     def length_sqrd(self:"Vector2D") -> float:
+        """
+        # Vector Length Squared
+
+        ## Returns:
+            float: The squared length (magnitude) of the vector.
+
+        ## Example:
+            v = Vector2D(3, 4)
+            length_sqrd = v.length_sqrd
+            print(length_sqrd)  # Output: 25
+
+        ## Explanation:
+            This property calculates the squared length (magnitude) of the vector.
+            It is more efficient than calculating the actual length, as it avoids the
+            square root calculation.
+        """
         ...
     
     @property
     def inverse(self:"Vector2D") -> "Vector2D":
+        """
+        # Vector Inversion
+
+        ## Returns:
+            Vector2D: A new vector with inverted components.
+
+        ## Example:
+            v = Vector2D(3, 4)
+            inverted_v = v.inverse()
+            print(inverted_v)  # Output: (-3, -4)
+
+        ## Explanation:
+            This method calculates the inverted version of the current vector, which means a new vector with the same magnitude
+            but opposite direction.
+
+            The inverted vector is obtained by negating each component of the current vector.
+
+            The resulting inverted vector is returned.
+        """
         ...
 
     def floor(self:"Vector2D", n:"int|float|Vector2D"=1) -> "Vector2D":
+        """
+        # Round the Vector2D components down to the nearest integer or specified decimal place.
+
+        ## Parameters:
+            n (int|float|Vector2D, optional): The decimal place to round down to. Default is 1.
+
+        ## Returns:
+            Vector2D: A new vector with rounded-down components.
+
+        ## Example:
+            v = Vector2D(3.14159, 2.71828)
+            rounded_v = v.floor(2)
+            print(rounded_v)  # Output: (3.14, 2.71)
+
+        ## Explanation:
+            This method rounds each component of the vector down to the nearest integer or specified decimal place.
+        """
         ...
 
     def ceil(self:"Vector2D", n:"int|float|Vector2D"=1) -> "Vector2D":
+        """
+        # Round the Vector2D components up to the nearest integer or specified decimal place.
+
+        ## Parameters:
+            n (int|float|Vector2D, optional): The decimal place to round up to. Default is 1.
+
+        ## Returns:
+            Vector2D: A new vector with rounded-up components.
+
+        ## Example:
+            v = Vector2D(3.14159, 2.71828)
+            rounded_v = v.ceil(2)
+            print(rounded_v)  # Output: (3.15, 2.72)
+
+        ## Explanation:
+            This method rounds each component of the vector up to the nearest integer or specified decimal place.
+        """
         ...
     
     def round(self:"Vector2D", n:"int|float|Vector2D"=1) -> "Vector2D":
+        """
+        # Round the Vector2D components to the nearest integer or specified decimal place.
+
+        ## Parameters:
+            n (int|float|Vector2D, optional): The decimal place to round to. Default is 1.
+
+        ## Returns:
+            Vector2D: A new vector with rounded components.
+
+        ## Example:
+            v = Vector2D(3.14159, 2.71828)
+            rounded_v = v.round(2)
+            print(rounded_v)  # Output: (3.14, 2.72)
+
+        ## Explanation:
+            This method rounds each component of the vector to the nearest integer or specified decimal place.
+        """
         ...
 
     @classmethod
@@ -500,7 +649,65 @@ class Vector2D:
     def cartesian_to_complex(self:"Vector2D") -> complex: ...
 
     @classmethod
-    def complex_to_cartesian(cls, complex_n: complex) -> "Vector2D": ...
+    def complex_to_cartesian(cls, complex_n: complex) -> "Vector2D":
+        """
+        # Convert a Complex Number to Cartesian Coordinates
+
+        ## Parameters:
+            complex_n (complex): The complex number to convert.
+
+        ## Returns:
+            Vector2D: The corresponding (x, y) coordinates as a Vector2D.
+
+        ## Example:
+            v = Vector2D.complex_to_cartesian(3 + 4j)  # v = Vector2D(3, 4)
+
+        ## Explanation:
+            This class method converts a complex number (a + bi) to Cartesian coordinates (x, y).
+            The real part 'a' becomes the x-coordinate, and the imaginary part 'b' becomes the y-coordinate.
+        """
+        ...
+
+    def cartesian_to_linear(self:"Vector2D", size:int|float) -> int:
+        """
+        # Convert 2D Cartesian coordinates to a linear index.
+
+        ## Parameters:
+            size (int|float): The width of the grid (number of columns).
+
+        ## Returns:
+            int: The linear index corresponding to the (x, y) coordinates.
+
+        ## Example:
+            v = Vector2D(3, 2)
+            idx = v.cartesian_to_linear(5)  # idx = 3 + 2*5 = 13
+
+        ## Explanation:
+            This method converts the (x, y) coordinates of the vector to a single linear index,
+            assuming row-major order in a 2D grid of the given width.
+        """
+        ...
+
+    @classmethod
+    def linear_to_cartesian(cls, linear:int, size:int|float) -> "Vector2D":
+        """
+        # Convert a linear index to 2D Cartesian coordinates.
+
+        ## Parameters:
+            linear (int): The linear index.
+            size (int|float): The width of the grid (number of columns).
+
+        ## Returns:
+            Vector2D: The corresponding (x, y) coordinates as a Vector2D.
+
+        ## Example:
+            v = Vector2D.linear_to_cartesian(13, 5)  # v = Vector2D(3, 2)
+
+        ## Explanation:
+            This class method converts a linear index to (x, y) coordinates,
+            assuming row-major order in a 2D grid of the given width.
+        """
+        ...
 
     def lerp(self:"Vector2D", other:"int|float|Vector2D|list|tuple", t:float=.1) -> "Vector2D":
         """
@@ -1095,4 +1302,37 @@ def distance_line_point(line_point_a:Vector2D, line_point_b:Vector2D, point_c:Ve
     ...
 
 def optimize_value_string(value: int|float, precision: int) -> str:
+    """
+    # Optimize the string representation of a numeric value based on its magnitude and the specified precision.
+
+    ## Parameters:
+        value (int | float): The numeric value to be formatted.
+        precision (int): The number of decimal places or significant digits to use in the formatted string.
+
+    ## Returns:
+        str: The optimized string representation of the value.
+
+    ## Example:
+        value = 0.000012345
+        precision = 3
+        result = optimize_value_string(value, precision)
+        print(result)
+        # Output: '1.235e-05'
+
+        value = 123.456789
+        precision = 2
+        result = optimize_value_string(value, precision)
+        print(result)
+        # Output: '123.46'
+
+    ## Explanation:
+        The function formats the input value as a string, choosing between fixed-point and scientific notation
+        based on the magnitude of the value relative to the specified precision:
+            - If the absolute value is very small (less than 1 divided by 10 to the power of precision, but not zero),
+                scientific notation is used.
+            - If the absolute value is less than 10 to the power of precision, fixed-point notation is used,
+                with trailing zeros and decimal points removed for brevity.
+            - Otherwise, scientific notation is used.
+        This ensures that the string representation is concise and readable, while maintaining the requested precision.
+    """
     ...

{e2d-1.4.20 → e2d-1.4.21}/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
     
@@ -110,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
@@ -146,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":
@@ -392,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]:
@@ -412,7 +413,7 @@ 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)
@@ -426,13 +427,26 @@ 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 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) -> "Color":
-        return Color(__randint__(0,255), __randint__(0,255), __randint__(0,255))
+    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()
@@ -441,6 +455,9 @@ 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()
@@ -448,3 +465,6 @@ 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-1.4.20 → e2d-1.4.21}/e2D/envs.py

@@ -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,6 +58,7 @@ 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]= []
@@ -67,6 +70,13 @@ class RootEnv:
         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 init_rec(self, fps:int=30, path:str='output.mp4') -> None:
+        from .winrec import WinRec
+        self.__winrecorder__ = WinRec(self, fps=fps, path=path)
+
     @property
     def background_color(self) -> Color:
         return unpygamize_color(self.__background_color__)
@@ -81,19 +91,24 @@ 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
+        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:
+    def update_screen_mode(self, vsync:None|bool=None, flags=None, display_index=None) -> None:
         self.__vsync__ = vsync
         self.__flags__ = 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__)
 
     def sleep(self, seconds:int|float, precise_delay=False) -> None:
         if precise_delay:
@@ -106,7 +121,7 @@ class RootEnv:
             if util.surface == None: util.surface = self.screen
             util.rootEnv = self
             util.id = self.__new_util_id__()
-            util.render()
+            util.__render__()
             self.utils[util.id] = util
 
     def remove_utils(self, *utils:int|str|Util) -> None:
@@ -169,24 +184,32 @@ class RootEnv:
         surface.blit(text_box, pivotted_position())
 
     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__()
 
-        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__()
+
+        if hasattr(self, "__winrecorder__"):
+            self.__winrecorder__.update()
+            self.__winrecorder__.draw()
 
     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__()
@@ -194,4 +217,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

{e2d-1.4.20 → e2d-1.4.21}/e2D/utils.py

@@ -33,32 +33,51 @@ __PIVOT_POSITIONS_MULTIPLIER__ = dict(zip(("top_left", "top_center", "top_right"
 class Mouse:
     def __init__(self, parent) -> None:
         self.parent = parent
-        self.__last_frame_position_count__ = 0
-        self.__last_frame_position__ = Vector2D.new_zero()
-        self.__last_frame_movement_count__ = 0
-        self.__last_frame_movement__ = Vector2D.new_zero()
-        
+        self.__last_frame_position_number__ :int= 0
+        self.__last_frame_position__ :Vector2D= Vector2D.new_zero()
+        self.__last_frame_movement_number__ :int= 0
+        self.__last_frame_movement__ :Vector2D= Vector2D.new_zero()
+        self.__last_frame_wheel_number__ :int= 0
+        self.__last_frame_wheel_delta__ :int= 0
+
         self.__pressed__ : tuple[bool, bool, bool] = (False, False, False)
-        self.update()    
+        self.update()
+
+    @property
+    def wheel_delta(self) -> int:
+        for event in self.parent.events:
+            if event.type == pg.MOUSEWHEEL:
+                if self.__last_frame_wheel_number__ != self.parent.current_frame:
+                    self.__last_frame_wheel_delta__ = event.y
+                    self.__last_frame_wheel_number__ = self.parent.current_frame
+                return self.__last_frame_wheel_delta__
+        
+        self.__last_frame_wheel_delta__ = 0
+        self.__last_frame_wheel_number__ = self.parent.current_frame
+        return self.__last_frame_wheel_delta__
 
     @property
     def position(self) -> Vector2D:
-        if self.__last_frame_position_count__ != self.parent.current_frame:
+        if self.__last_frame_position_number__ != self.parent.current_frame:
             self.__last_frame_position__ = Vector2D(*pg.mouse.get_pos())
-            self.__last_frame_position_count__ = self.parent.current_frame
+            self.__last_frame_position_number__ = self.parent.current_frame
         return self.__last_frame_position__
     @position.setter
     def position(self, new_position:Vector2D) -> None:
-        self.__last_frame_position_count__ = self.parent.current_frame
+        self.__last_frame_position_number__ = self.parent.current_frame
         self.__last_frame_position__ = new_position
         pg.mouse.set_pos(self.__last_frame_position__())
     
     @property
     def last_frame_movement(self) -> Vector2D:
-        if self.__last_frame_movement_count__ != self.parent.current_frame:
+        if self.__last_frame_movement_number__ != self.parent.current_frame:
             self.__last_frame_movement__ = Vector2D(*pg.mouse.get_rel())
-            self.__last_frame_movement_count__ = self.parent.current_frame
+            self.__last_frame_movement_number__ = self.parent.current_frame
         return self.__last_frame_movement__
+    @last_frame_movement.setter
+    def last_frame_movement(self, new_movement:Vector2D) -> None:
+        self.__last_frame_movement_number__ = self.parent.current_frame
+        self.__last_frame_movement__ = new_movement
 
     def update(self) -> None:
         self.__last_pressed__ = self.__pressed__
@@ -95,8 +114,8 @@ class Keyboard:
 
 class Util:
     def __init__(self) -> None:
-        self.rootEnv = None
-        self.surface : pg.Surface = pg.SurfaceType
+        self.rootEnv : Any
+        self.surface : pg.Surface= None # type: ignore
         self.id : int|str
         self.is_hovered :bool= False
         self.hidden :bool= False
@@ -104,9 +123,9 @@ class Util:
         self.hidden = True
     def show(self) -> None:
         self.hidden = False
-    def render(self) -> None: pass
-    def draw(self) -> None: pass
-    def update(self) -> None: pass
+    def __render__(self) -> None: pass
+    def __draw__(self) -> None: pass
+    def __update__(self) -> None: pass
 
 class InputCell(Util):
     def __init__(self,
@@ -176,7 +195,7 @@ class InputCell(Util):
     def border_color(self, new_color:Color|pg.Color) -> None:
         self.__border_color__ = pygamize_color(new_color)
 
-    def draw(self) -> None:
+    def __draw__(self) -> None:
         if self.hidden: return
         self.text_surface.fill(TRANSPARENT_COLOR_PYG)
         
@@ -194,7 +213,7 @@ class InputCell(Util):
 
         self.surface.blit(self.text_surface, self.position())
         
-    def update(self) -> None:
+    def __update__(self) -> None:
         if self.hidden: return
         self.is_hovered = self.position.x < self.rootEnv.mouse.position.x < self.position.x + self.size.x and\
                           self.position.y < self.rootEnv.mouse.position.y < self.position.y + self.size.y
@@ -261,7 +280,7 @@ class Slider(Util):
         self.text_pivot = text_pivot
 
         self.handleRadius = handleRadius
-        self.surface = personalized_surface
+        self.surface = personalized_surface # type: ignore
 
         self.hidden = False
 
@@ -281,21 +300,21 @@ class Slider(Util):
     def handleColour(self, new_color:Color|pg.Color) -> None:
         self.__handleColour__ = pygamize_color(new_color)
 
-    def draw(self) -> None:
+    def __draw__(self) -> None:
         if self.hidden: return
-        pg.draw.rect(self.rootEnv.screen, self.__color__, self.position() + self.size())
+        pg.draw.rect(self.surface, self.__color__, self.position() + self.size())
 
         if self.radius:
-            pg.draw.circle(self.rootEnv.screen, self.__color__, (self.position.x, self.position.y + self.size.y // 2), self.radius)
-            pg.draw.circle(self.rootEnv.screen, self.__color__, (self.position.x + self.size.x, self.position.y + self.size.y // 2), self.radius)
+            pg.draw.circle(self.surface, self.__color__, (self.position.x, self.position.y + self.size.y // 2), self.radius)
+            pg.draw.circle(self.surface, self.__color__, (self.position.x + self.size.x, self.position.y + self.size.y // 2), self.radius)
 
         circle = V2(int(self.position.x + (self.value - self.min) / (self.max - self.min) * self.size.x), self.position.y + self.size.y // 2)
 
-        pg.draw.circle(self.rootEnv.screen, self.__color__, circle(), self.handleRadius * 1.25)
-        pg.draw.circle(self.rootEnv.screen, self.__handleColour__, circle(), self.handleRadius)
+        pg.draw.circle(self.surface, self.__color__, circle(), self.handleRadius * 1.25)
+        pg.draw.circle(self.surface, self.__handleColour__, circle(), self.handleRadius)
         self.rootEnv.print(self.text.format(round(self.value, 2)), self.position + self.size * self.text_offset, pivot_position=self.text_pivot)
     
-    def update(self) -> None:
+    def __update__(self) -> None:
         if self.hidden: return
         x,y = self.rootEnv.mouse.position
 
@@ -324,22 +343,22 @@ class Button(Util):
                 text : str,
                 position : V2|Vector2D,
                 size : V2|Vector2D,
-                callback : Callable[[...], None]|Callable[[], None],
-                default_color : Color|pg.Color,
-                hovered_color : Color|pg.Color,
-                border_color : Color|pg.Color,
+                callback : Callable[[], None]|Callable[[], None] = lambda: None,
+                default_bg_color : Color|pg.Color = BLUE_COLOR_PYG,
+                hovered_bg_color : Color|pg.Color = CYAN_COLOR_PYG,
+                border_color : Color|pg.Color = WHITE_COLOR_PYG,
                 text_color : Color|pg.Color = WHITE_COLOR_PYG,
                 font : pg.font.Font = FONT_ARIAL_32,
                 border_radius : float = 10,
                 border_width : float = 10,
-                starting_hiddden : bool = False,
+                starting_hidden : bool = False,
                 args : list = [],
                 activation_mode : __LITERAL_KEY_MODE_TYPES__ = "just_pressed",
                 pivot_position : __LITERAL_PIVOT_POSITIONS__ = "top_left",
                 personalized_surface : pg.Surface|None = None,
             ) -> None:
         super().__init__()
-        
+
         self.text = text
         self.font = font
 
@@ -348,10 +367,11 @@ class Button(Util):
         self.border_radius = border_radius
         self.__size__ = size
         self.__border_width__ = border_width
-        
-        self.update_position(position, pivot_position)
 
-        self.hidden = starting_hiddden
+        self.pivot_position :__LITERAL_PIVOT_POSITIONS__= pivot_position    
+        self.update_position(position)
+
+        self.hidden = starting_hidden
         self.args = args
 
         self.activation_mode = activation_mode
@@ -359,19 +379,23 @@ class Button(Util):
         self.hovered = False
 
         self.text_color = text_color
-        self.default_color = default_color
+        self.default_bg_color = default_bg_color
         self.border_color = border_color
-        self.hovered_color = hovered_color
+        self.hovered_bg_color = hovered_bg_color
 
-        self.surface = personalized_surface
+        self.surface = personalized_surface #type: ignore
         self.update_surface()
     
-    def update_position(self, new_position:V2, pivot_position:__LITERAL_PIVOT_POSITIONS__="top_left") -> None:
-        self.position = new_position - (self.__size__ + self.border_width * 2) * __PIVOT_POSITIONS_MULTIPLIER__[pivot_position]
+    def update_position(self, new_position:V2) -> None:
+        self.position = new_position - self.__size__ * __PIVOT_POSITIONS_MULTIPLIER__[self.pivot_position]
+
+    def update_pivoting(self, new_pivot_position:__LITERAL_PIVOT_POSITIONS__) -> None:
+        self.pivot_position = new_pivot_position
+        self.update_position(self.position)
     
     def update_surface(self, render=False) -> None:
         self.buffer_surface = pg.Surface((self.__size__ + self.__border_width__ * 2)(), pg.SRCALPHA, 32).convert_alpha()
-        if render: self.render()
+        if render: self.__render__()
 
     @property
     def size(self) -> V2:
@@ -386,6 +410,7 @@ class Button(Util):
         return self.__border_width__
     @border_width.setter
     def border_width(self, new_width:float) -> None:
+        # self.position -= (self.__border_width__ - new_width) * .5
         self.__border_width__ = new_width
         self.update_surface(render=True)
     
@@ -396,11 +421,11 @@ class Button(Util):
     def text_color(self, new_color:Color|pg.Color) -> None:
         self.__text_color__ = pygamize_color(new_color)
     @property
-    def default_color(self) -> Color:
-        return unpygamize_color(self.__default_color__)
-    @default_color.setter
-    def default_color(self, new_color:Color|pg.Color) -> None:
-        self.__default_color__ = pygamize_color(new_color)
+    def default_bg_color(self) -> Color:
+        return unpygamize_color(self.__default_bg_color__)
+    @default_bg_color.setter
+    def default_bg_color(self, new_color:Color|pg.Color) -> None:
+        self.__default_bg_color__ = pygamize_color(new_color)
     @property
     def border_color(self) -> Color:
         return unpygamize_color(self.__border_color__)
@@ -408,27 +433,28 @@ class Button(Util):
     def border_color(self, new_color:Color|pg.Color) -> None:
         self.__border_color__ = pygamize_color(new_color)
     @property
-    def hovered_color(self) -> Color:
-        return unpygamize_color(self.__hovered_color__)
-    @hovered_color.setter
-    def hovered_color(self, new_color:Color|pg.Color) -> None:
-        self.__hovered_color__ = pygamize_color(new_color)
-
-    def render(self) -> None:
-        print("rendering button")
+    def hovered_bg_color(self) -> Color:
+        return unpygamize_color(self.__hovered_bg_color__)
+    @hovered_bg_color.setter
+    def hovered_bg_color(self, new_color:Color|pg.Color) -> None:
+        self.__hovered_bg_color__ = pygamize_color(new_color)
+
+    def __render__(self) -> None:
         self.buffer_surface.fill(TRANSPARENT_COLOR_PYG)
 
-        color = self.__hovered_color__ if self.hovered else self.__default_color__
+        color = self.__hovered_bg_color__ if self.hovered else self.__default_bg_color__
         pg.draw.rect(self.buffer_surface, self.__border_color__, V2.zero()() + (self.size + self.border_width * 2)(), border_radius=self.border_radius)
         pg.draw.rect(self.buffer_surface, color, (V2.zero() + self.border_width)() + self.size(), border_radius=self.border_radius)
 
+        # TODO:
+        # not only size * .5 but also internal pivoting on the corners and sides
         self.rootEnv.print(self.text, self.border_width + self.size * .5, color=self.__text_color__, font=self.font, pivot_position="center_center", personalized_surface=self.buffer_surface)
 
-    def draw(self) -> None:
+    def __draw__(self) -> None:
         if self.hidden: return
         self.surface.blit(self.buffer_surface, (self.position)())
 
-    def update(self) -> None:
+    def __update__(self) -> None:
         if self.hidden: return
 
         old_overed = self.hovered
@@ -436,15 +462,15 @@ class Button(Util):
             self.position.x < self.rootEnv.mouse.position.x < self.position.x + self.size.x and \
             self.position.y < self.rootEnv.mouse.position.y < self.position.y + self.size.y
         if self.hovered != old_overed:
-            self.render()
+            self.__render__()
         
         if self.hovered and self.rootEnv.mouse.get_key(0, self.activation_mode):
             self.callback(*self.args)
             self.rootEnv.selected_util = self
-            self.render()
+            self.__render__()
         elif self.rootEnv.selected_util == self:
             self.rootEnv.selected_util = None
-            self.render()
+            self.__render__()
 
 class Label(Util):
     def __init__(self,
@@ -457,7 +483,7 @@ class Label(Util):
                 font : pg.font.Font = FONT_ARIAL_32,
                 border_radius : float = 10,
                 border_width : float = 10,
-                starting_hiddden : bool = False,
+                starting_hidden : bool = False,
                 personalized_surface : pg.Surface|None = None,
                 pivot_position : __LITERAL_PIVOT_POSITIONS__ = "top_left",
             ) -> None:
@@ -470,23 +496,28 @@ class Label(Util):
         self.__size__ = size
         self.__border_width__ = border_width
         
-        self.position = self.update_position(position, pivot_position)
+        self.pivot_position :__LITERAL_PIVOT_POSITIONS__= pivot_position
+        self.update_position(position)
 
-        self.hidden = starting_hiddden
+        self.hidden = starting_hidden
 
         self.text_color = text_color
         self.default_color = default_color
         self.border_color = border_color
 
-        self.surface = personalized_surface
+        self.surface = personalized_surface # type: ignore
         self.update_surface()
     
-    def update_position(self, new_position:V2, pivot_position:__LITERAL_PIVOT_POSITIONS__="top_left") -> None:
-        self.position = new_position - (self.__size__ + self.border_width * 2) * __PIVOT_POSITIONS_MULTIPLIER__[pivot_position]
-    
+    def update_position(self, new_position:V2) -> None:
+        self.position = new_position - (self.__size__ + self.border_width * 2) * __PIVOT_POSITIONS_MULTIPLIER__[self.pivot_position]
+
+    def update_pivoting(self, new_pivot_position:__LITERAL_PIVOT_POSITIONS__="top_left") -> None:
+        self.pivot_position = new_pivot_position
+        self.update_position(self.position)
+
     def update_surface(self, render=False) -> None:
         self.buffer_surface = pg.Surface((self.__size__ + self.__border_width__ * 2)(), pg.SRCALPHA, 32).convert_alpha()
-        if render: self.render()
+        if render: self.__render__()
 
     @property
     def text(self) -> str:
@@ -494,7 +525,7 @@ class Label(Util):
     @text.setter
     def text(self, new_text:str) -> None:
         self.__text__ = new_text
-        self.render()
+        self.__render__()
 
     @property
     def size(self) -> V2:
@@ -531,15 +562,16 @@ class Label(Util):
     def border_color(self, new_color:Color|pg.Color) -> None:
         self.__border_color__ = pygamize_color(new_color)
 
-    def render(self) -> None:
-        print("rendering label")
+    def __render__(self) -> None:
         self.buffer_surface.fill(TRANSPARENT_COLOR_PYG)
 
         pg.draw.rect(self.buffer_surface, self.__border_color__, V2.zero()() + (self.size + self.border_width * 2)(), border_radius=self.border_radius)
         pg.draw.rect(self.buffer_surface, self.__default_color__, (V2.zero() + self.border_width)() + self.size(), border_radius=self.border_radius)
 
+        # TODO:
+        # not only size * .5 but also internal pivoting on the corners and sides
         self.rootEnv.print(self.text, self.border_width + self.size * .5, color=self.__text_color__, font=self.font, pivot_position="center_center", personalized_surface=self.buffer_surface)
 
-    def draw(self) -> None:
+    def __draw__(self) -> None:
         if self.hidden: return
         self.surface.blit(self.buffer_surface, (self.position)())

{e2d-1.4.20 → e2d-1.4.21}/e2D.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: e2D
-Version: 1.4.20
+Version: 1.4.21
 Summary: Python library for 2D games. Streamlines dev with keyboard/mouse input, vector calculations, color manipulation, and collision detection. Simplify game creation and unleash creativity!
 Home-page: https://github.com/marick-py/e2D
 Author: Riccardo Mariani

{e2d-1.4.20 → e2d-1.4.21}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = e2D
-version = 1.4.20
+version = 1.4.21
 author = Riccardo Mariani
 author_email = ricomari2006@gmail.com
 description = Python library for 2D games. Streamlines dev with keyboard/mouse input, vector calculations, color manipulation, and collision detection. Simplify game creation and unleash creativity!