e2D 1.4.17__tar.gz → 1.4.19__tar.gz

{e2d-1.4.17 → e2d-1.4.19}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 Riko Mari
+Copyright (c) 2025 Riccardo Mariani
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{e2d-1.4.17 → e2d-1.4.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: e2D
-Version: 1.4.17
+Version: 1.4.19
 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.17 → e2d-1.4.19}/e2D/__init__.py

@@ -71,7 +71,7 @@ class Vector2D:
         return self.__round__(n)
 
     @classmethod
-    def randomize(cls, start, end) -> "Vector2D":
+    def randomize(cls, start, end, func=lambda val:val) -> "Vector2D":
         if not isinstance(start, Vector2D):
             if isinstance(start, (int, float)):
                 start = Vector2D(start, start)
@@ -82,7 +82,7 @@ class Vector2D:
                 end = Vector2D(end, end)
             else:
                 raise Exception(f"\nArg end must be in [Vector2D, int, float, tuple, list] not a [{type(end)}]\n")
-        return start + Vector2D(_rnd.random(), _rnd.random()) * (end - start)
+        return start + Vector2D(func(_rnd.random()), func(_rnd.random())) * (end - start)
     
     def dot_product(self, other) -> float:
         return self.x * other.x + self.y * other.y
@@ -498,27 +498,6 @@ VECTORS_4_SEMIDIRECTIONS_NORM = (V2down_right_norm, V2down_left_norm, V2up_left_
 VECTORS_8_DIRECTIONS = (V2right, V2down_right, V2down, V2down_left, V2left, V2up_left, V2up, V2up_right)
 VECTORS_8_DIRECTIONS_NORM = (V2right, V2down_right_norm, V2down, V2down_left_norm, V2left, V2up_left_norm, V2up, V2up_right_norm)
 
-
-def rgb(r:float, g:float, b:float) -> tuple[float, float, float]:
-    return (r,g,b)
-
-def color_lerp(current_c:list|tuple, final_c:list|tuple, step=.1) -> tuple[float, float, float]:
-    return tuple(c + (final_c[i] - c) * step for i,c in enumerate(current_c)) #type: ignore
-
-def color_fade(starting_c:list|tuple, final_c:list|tuple, index, max_index) -> tuple[float, float, float]:
-    return tuple((starting_c[i] - final_c[i]) / max_index * (max_index - index) + final_c[i] for i in range(3)) #type: ignore
-
-def weighted_color_fade(colors_dict:dict) -> tuple[float, float, float]:
-    colors = colors_dict.keys()
-    weights = colors_dict.values()
-
-    if float("inf") in weights: return list(colors)[list(weights).index(float("inf"))]
-    return tuple(sum(n[i]*w for n,w in zip(colors, weights)) / sum(weights) for i in range(3)) #type: ignore
-
-def color_distance(starting_c:list|tuple, final_c:list|tuple, rooted) -> float:
-    distance = sum([(starting_c[i]-final_c[i])**2 for i in range(3)])
-    return (distance ** .5) if rooted else distance
-
 def lerp(starting, ending, step=.1) -> float:
     return starting + (ending - starting) * step
 

{e2d-1.4.17 → e2d-1.4.19}/e2D/__init__.pyi

@@ -264,7 +264,7 @@ class Vector2D:
         ...
 
     @classmethod
-    def randomize(cls, start:"int|float|Vector2D", end:"int|float|Vector2D") -> "Vector2D":
+    def randomize(cls, start:"int|float|Vector2D", end:"int|float|Vector2D", func:Callable[[int|float], int|float]=lambda val:val) -> "Vector2D":
         """
         # Generate a random Vector2D point within the specified range.
 
@@ -800,140 +800,8 @@ VECTORS_4_SEMIDIRECTIONS_NORM : tuple[Vector2D, Vector2D, Vector2D, Vector2D,]
 VECTORS_8_DIRECTIONS : tuple[Vector2D, Vector2D, Vector2D, Vector2D, Vector2D, Vector2D, Vector2D, Vector2D]
 VECTORS_8_DIRECTIONS_NORM : tuple[Vector2D, Vector2D, Vector2D, Vector2D, Vector2D, Vector2D, Vector2D, Vector2D]
 
-
-def rgb(r:float, g:float, b:float) -> tuple[float, float, float]:
-    return (r,g,b)
-
 def lerp(starting: int|float, ending: int|float, step: int|float=.1) -> float: ...
 
-def color_lerp(current_c: list|tuple, final_c: list|tuple, step: int|float=.1) -> tuple[float, float, float]:
-    """
-    # Linearly interpolate between two colors.
-
-    ## Parameters:
-        current_c (tuple or list): The RGB values of the current color as a tuple or list.
-        final_c (tuple or list): The RGB values of the target color as a tuple or list.
-        step (int or float): The interpolation step, ranging from 0.0 (current color) to 1.0 (target color).
-
-    ## Returns:
-        tuple: The RGB values of the interpolated color as a tuple.
-
-    ## Example:
-        current_c = (255, 0, 0)
-
-        final_c = (0, 0, 255)
-
-        step = 0.5
-
-        interpolated_color = color_lerp(current_c, final_c, step)
-
-        print(f"At step {step}: RGB {interpolated_color}")
-        
-    This will calculate the color at an interpolation step of 0.5 between (255, 0, 0) and (0, 0, 255).
-    """
-    ...
-
-def color_fade(starting_c: list|tuple, final_c: list|tuple, index: int|float, max_index: int|float) -> tuple[float, float, float]:
-    """
-    # Calculate the color at a specific index of a color fade between two given colors.
-
-    ## Parameters:
-        starting_c (tuple or list): The RGB values of the starting color as a tuple or list.
-        final_c (tuple or list): The RGB values of the final color as a tuple or list.
-        index (int or float): The current index of the color fade, representing a position
-                              between the starting and final colors.
-        max_index (int or float): The maximum index of the color fade, indicating the endpoint
-                                  position between the starting and final colors.
-
-    ## Returns:
-        tuple: The RGB values of the color at the specified index as a tuple.
-
-    ## Example:
-        starting_c = (255, 0, 0)
-
-        final_c = (0, 0, 255)
-
-        max_index = 100
-
-        for i in range(max_index + 1):
-        
-            color_at_index = color_fade(starting_c, final_c, i, max_index)
-
-            print(f"At index {i}: RGB {color_at_index}")
-            
-        This will print the colors transitioning from (255, 0, 0) to (0, 0, 255).
-    """
-    ...
-
-def weighted_color_fade(colors_dict:dict) -> tuple[float, float, float]:
-    """
-    # Calculate the weighted color based on a dictionary of colors and their corresponding weights.
-
-    ## Parameters:
-        colors_dict (dict): A dictionary where keys represent RGB color values as tuples,
-                            and values represent the weights (floats) for each color.
-
-    ## Returns:
-        tuple: The RGB values of the calculated weighted color as a tuple.
-
-    ## Example:
-        colors_dict = {
-        
-            (255, 255, 255): 0.1,
-
-            (0, 0, 0): 0.9,
-
-        }
-
-        weighted_color = weighted_color_fade(colors_dict)
-
-        print(f"Weighted color: RGB {weighted_color}")
-
-        This will print the weighted color based on the provided dictionary.
-    """
-    ...
-
-def color_distance(starting_c: list|tuple, final_c: list|tuple, rooted:bool=True) -> float:
-    """
-    # Calculate the distance between two colors in RGB space.
-
-    ## Parameters:
-        starting_c (list or tuple): The RGB values of the starting color.
-        final_c (list or tuple): The RGB values of the final color.
-        rooted (bool, optional): If True, return the rooted distance. If False, return
-                               the actual distance. Default is True.
-
-    ## Returns:
-        float: The squared distance between the two colors if `rooted` is False, otherwise
-               the actual distance.
-
-    ## Example:
-        starting_c = [255, 0, 0]
-
-        final_c = [0, 255, 0]
-
-        squared_distance = color_distance(starting_c, final_c)
-
-        print(f"Squared Distance: {squared_distance}")
-
-        distance = color_distance(starting_c, final_c, rooted=True)
-
-        print(f"Actual Distance: {distance}")
-
-        This will calculate the squared and actual distances between the colors.
-
-    ## Explanation:
-        The function first calculates the squared distance between the two colors in RGB
-        space. It does this by computing the sum of the squared differences of the RGB
-        components for each color. The squared distance is obtained by taking the square
-        root of this sum.
-
-        The `rooted` parameter allows the user to choose between returning the squared
-        distance or the actual distance. If `rooted` is True, the function returns the
-        actual distance, and if `rooted` is False, it returns the squared distance.
-    """
-    ...
-
 def angular_interpolation(starting_angle: int|float, final_angle: int|float, step: int|float=.1) -> float:
     """
     # Perform angular interpolation between two angles using the shortest distance.

{e2d-1.4.17 → e2d-1.4.19}/e2D/colors.py

@@ -86,6 +86,22 @@ class Color:
     def __init__(self, *values, mode:__LITERAL_COLOR_MODES__=RGB_COLOR_MODE) -> None:
         self.__dict__ = dict(zip(mode, values))
         self.mode :__LITERAL_COLOR_MODES__= mode
+
+    def lerp(self, other:"Color", step=.1) -> "Color":
+        return (self + (other - self).mult(step))
+
+    @staticmethod
+    def weighted_lerp(colors_dict:dict["Color", float]) -> "Color":
+        """Colors HAVE to be in the rgb format."""
+
+        colors = colors_dict.keys()
+        weights = colors_dict.values()
+        if float("inf") in weights: return list(colors)[list(weights).index(float("inf"))]
+        return sum(n.mult(w) for n,w in zip(colors, weights)).div(sum(weights))
+
+    def distance_to(self, other:"Color", rooted=True) -> float:
+        d = sum((self.to_rgb() - other.to_rgb()).pow(2))
+        return (d ** .5) if rooted else d
     
     @classmethod
     def new_rgb(cls, r:int|float, g:int|float, b:int|float) -> "Color":
@@ -163,134 +179,107 @@ class Color:
         return "Color(" + ", ".join(f"{k}:{v}" for k, v in self.items) + ")"
 
     def __call__(self) -> __color_pygame__:
-        return __color_pygame__(*map(int, self.to_rgba().values))
+        return __color_pygame__(int(self.r), int(self.g), int(self.b))
     
     # fast operations     Vector2D.operation(both,x,y)
     def add(self, all3=.0, r=.0, g=.0, b=.0) -> "Color":
-        c_color = self.to_rgb()
-        return Color(c_color.r + (r + all3), c_color.g + (g + all3), c_color.b + (b + all3)).to_mode(self.mode) # type: ignore
+        return Color(self.r + (r + all3), self.g + (g + all3), self.b + (b + all3))
     
     def sub(self, all3=.0, r=.0, g=.0, b=.0) -> "Color":
-        c_color = self.to_rgb()
-        return Color(c_color.r - (r + all3), c_color.g - (g + all3), c_color.b - (b + all3)).to_mode(self.mode) # type: ignore
+        return Color(self.r - (r + all3), self.g - (g + all3), self.b - (b + all3))
     
     def mult(self, all3=1.0, r=1.0, g=1.0, b=1.0) -> "Color":
-        c_color = self.to_rgb()
-        return Color(c_color.r * r * all3, c_color.g * g * all3, c_color.b * b * all3).to_mode(self.mode) # type: ignore
+        return Color(self.r * r * all3, self.g * g * all3, self.b * b * all3)
     
     def pow(self, all3=1.0, r=1.0, g=1.0, b=1.0) -> "Color":
-        c_color = self.to_rgb()
-        return Color(c_color.r ** (r + all3), c_color.g ** (g + all3), c_color.b ** (b + all3)).to_mode(self.mode) # type: ignore
+        return Color(self.r ** (r + all3), self.g ** (g + all3), self.b ** (b + all3))
     
     def mod(self, all3=1.0, r=1.0, g=1.0, b=1.0) -> "Color":
-        c_color = self.to_rgb()
-        return Color(c_color.r % (r + all3), c_color.g % (g + all3), c_color.b % (b + all3)).to_mode(self.mode) # type: ignore
+        return Color(self.r % (r + all3), self.g % (g + all3), self.b % (b + all3))
     
     def div(self, all3=1.0, r=1.0, g=1.0, b=1.0) -> "Color":
-        c_color = self.to_rgb()
-        return Color(c_color.r / r / all3, c_color.g / g / all3, c_color.b / b / all3).to_mode(self.mode) # type: ignore
+        return Color(self.r / r / all3, self.g / g / all3, self.b / b / all3)
     
     def fdiv(self, all3=1.0, r=1.0, g=1.0, b=1.0) -> "Color":
-        c_color = self.to_rgb()
-        return Color(c_color.r // r // all3, c_color.g // g // all3, c_color.b // b // all3).to_mode(self.mode) # type: ignore
+        return Color(self.r // r // all3, self.g // g // all3, self.b // b // all3)
 
     # fast inplace operations     Vector2D.ioperation(both,x,y)
-    def set(self, both=.0, x=.0, y=.0) -> "Color":
-        self.x = x + both
-        self.y = y + both
+    def set(self, all3=.0, r=.0, g=.0, b=.0) -> "Color":
+        self.r = r + all3
+        self.g = g + all3
+        self.b = b + all3
         return self
 
     def iadd(self, all3=.0, r=.0, g=.0, b=.0) -> "Color":
-        c_color = self.to_rgb()
-        c_color.r += r + all3 # type: ignore
-        c_color.g += g + all3 # type: ignore
-        c_color.b += b + all3 # type: ignore
-        self.__dict__ = c_color.to_mode(self.mode).__dict__
+        self.r += r + all3
+        self.g += g + all3
+        self.b += b + all3
         return self
     
     def isub(self, all3=.0, r=.0, g=.0, b=.0) -> "Color":
-        c_color = self.to_rgb()
-        c_color.r -= r + all3 # type: ignore
-        c_color.g -= g + all3 # type: ignore
-        c_color.b -= b + all3 # type: ignore
-        self.__dict__ = c_color.to_mode(self.mode).__dict__
+        self.r -= r + all3
+        self.g -= g + all3
+        self.b -= b + all3
         return self
     
     def imult(self, all3=1.0, r=1.0, g=1.0, b=1.0) -> "Color":
-        c_color = self.to_rgb()
-        c_color.r *= r * all3 # type: ignore
-        c_color.g *= g * all3 # type: ignore
-        c_color.b *= b * all3 # type: ignore
-        self.__dict__ = c_color.to_mode(self.mode).__dict__
+        self.r *= r * all3
+        self.g *= g * all3
+        self.b *= b * all3
         return self
     
     def ipow(self, all3=1.0, r=1.0, g=1.0, b=1.0) -> "Color":
-        c_color = self.to_rgb()
-        c_color.r **= r + all3 # type: ignore
-        c_color.g **= g + all3 # type: ignore
-        c_color.b **= b + all3 # type: ignore
-        self.__dict__ = c_color.to_mode(self.mode).__dict__
+        self.r **= r + all3
+        self.g **= g + all3
+        self.b **= b + all3
         return self
     
     def imod(self, all3=1.0, r=1.0, g=1.0, b=1.0) -> "Color":
-        c_color = self.to_rgb()
-        c_color.r %= r + all3 # type: ignore
-        c_color.g %= g + all3 # type: ignore
-        c_color.b %= b + all3 # type: ignore
-        self.__dict__ = c_color.to_mode(self.mode).__dict__
+        self.r %= r + all3
+        self.g %= g + all3
+        self.b %= b + all3
         return self
     
     def idiv(self, all3=1.0, r=1.0, g=1.0, b=1.0) -> "Color":
-        c_color = self.to_rgb()
-        c_color.r /= r * all3 # type: ignore
-        c_color.g /= g * all3 # type: ignore
-        c_color.b /= b * all3 # type: ignore
-        self.__dict__ = c_color.to_mode(self.mode).__dict__
+        self.r /= r * all3
+        self.g /= g * all3
+        self.b /= b * all3
         return self
     
     def ifdiv(self, all3=1.0, r=1.0, g=1.0, b=1.0) -> "Color":
-        c_color = self.to_rgb()
-        c_color.r //= r * all3 # type: ignore
-        c_color.g //= g * all3 # type: ignore
-        c_color.b //= b * all3 # type: ignore
-        self.__dict__ = c_color.to_mode(self.mode).__dict__
+        self.r //= r * all3
+        self.g //= g * all3
+        self.b //= b * all3
         return self
 
     # normal operations     Vector2D + a
     def __add__(self, other) -> "Color":
         other = Color.__normalize__(other)
-        c_color = self.to_rgb()
-        return Color(c_color.r + other.r, c_color.g + other.g, c_color.b + other.b).to_mode(self.mode) # type: ignore
+        return Color(self.r + other.r, self.g + other.g, self.b + other.b)
     
     def __sub__(self, other) -> "Color":
         other = Color.__normalize__(other)
-        c_color = self.to_rgb()
-        return Color(c_color.r - other.r, c_color.g - other.g, c_color.b - other.b).to_mode(self.mode) # type: ignore
+        return Color(self.r - other.r, self.g - other.g, self.b - other.b)
     
     def __mul__(self, other) -> "Color":
         other = Color.__normalize__(other)
-        c_color = self.to_rgb()
-        return Color(c_color.r * other.r, c_color.g * other.g, c_color.b * other.b).to_mode(self.mode) # type: ignore
+        return Color(self.r * other.r, self.g * other.g, self.b * other.b)
 
     def __mod__(self, other) -> "Color":
         other = Color.__normalize__(other)
-        c_color = self.to_rgb()
-        return Color(c_color.r % other.r, c_color.g % other.g, c_color.b % other.b).to_mode(self.mode) # type: ignore
+        return Color(self.r % other.r, self.g % other.g, self.b % other.b)
     
     def __pow__(self, other) -> "Color":
         other = Color.__normalize__(other)
-        c_color = self.to_rgb()
-        return Color(c_color.r ** other.r, c_color.g ** other.g, c_color.b ** other.b).to_mode(self.mode) # type: ignore
+        return Color(self.r ** other.r, self.g ** other.g, self.b ** other.b)
 
     def __truediv__(self, other) -> "Color":
         other = Color.__normalize__(other)
-        c_color = self.to_rgb()
-        return Color(c_color.r / other.r, c_color.g / other.g, c_color.b / other.b).to_mode(self.mode) # type: ignore
+        return Color(self.r / other.r, self.g / other.g, self.b / other.b)
 
     def __floordiv__(self, other) -> "Color":
         other = Color.__normalize__(other)
-        c_color = self.to_rgb()
-        return Color(c_color.r // other.r, c_color.g // other.g, c_color.b // other.b).to_mode(self.mode) # type: ignore
+        return Color(self.r // other.r, self.g // other.g, self.b // other.b)
     
     # right operations      a + Vector2D
     def __radd__(self, other) -> "Color":
@@ -298,128 +287,104 @@ class Color:
     
     def __rsub__(self, other) -> "Color":
         other = Color.__normalize__(other)
-        c_color = self.to_rgb()
-        return Color(other.r - c_color.r, other.g - c_color.g, other.b - c_color.b).to_mode(self.mode) # type: ignore
+        return Color(other.r - self.r, other.g - self.g, other.b - self.b)
     
     def __rmul__(self, other) -> "Color":
         return self.__mul__(other)
 
     def __rmod__(self, other) -> "Color":
         other = Color.__normalize__(other)
-        c_color = self.to_rgb()
-        return Color(other.r % c_color.r, other.g % c_color.g, other.b % c_color.b).to_mode(self.mode) # type: ignore
+        return Color(other.r % self.r, other.g % self.g, other.b % self.b)
     
     def __rpow__(self, other) -> "Color":
         other = Color.__normalize__(other)
-        c_color = self.to_rgb()
-        return Color(other.r ** c_color.r, other.g ** c_color.g, other.b ** c_color.b).to_mode(self.mode) # type: ignore
+        return Color(other.r ** self.r, other.g ** self.g, other.b ** self.b)
 
     def __rtruediv__(self, other) -> "Color":
         other = Color.__normalize__(other)
-        c_color = self.to_rgb()
-        return Color(other.r / c_color.r, other.g / c_color.g, other.b / c_color.b).to_mode(self.mode) # type: ignore
+        return Color(other.r / self.r, other.g / self.g, other.b / self.b)
 
     def __rfloordiv__(self, other) -> "Color":
         other = Color.__normalize__(other)
-        c_color = self.to_rgb()
-        return Color(other.r // c_color.r, other.g // c_color.g, other.b // c_color.b).to_mode(self.mode) # type: ignore
+        return Color(other.r // self.r, other.g // self.g, other.b // self.b)
     
     # in-place operations   Vector2D += a
     def __iadd__(self, other) -> "Color":
         other = Color.__normalize__(other)
-        c_color = self.to_rgb()
-        c_color.r += other.r # type: ignore
-        c_color.g += other.g # type: ignore
-        c_color.b += other.b # type: ignore
-        self.__dict__ = c_color.to_mode(self.mode).__dict__
+        self.r += other.r
+        self.g += other.g
+        self.b += other.b
         return self
 
     def __isub__(self, other) -> "Color":
         other = Color.__normalize__(other)
-        c_color = self.to_rgb()
-        c_color.r -= other.r # type: ignore
-        c_color.g -= other.g # type: ignore
-        c_color.b -= other.b # type: ignore
-        self.__dict__ = c_color.to_mode(self.mode).__dict__
+        self.r -= other.r
+        self.g -= other.g
+        self.b -= other.b
         return self
     
     def __imul__(self, other) -> "Color":
         other = Color.__normalize__(other)
-        c_color = self.to_rgb()
-        c_color.r *= other.r # type: ignore
-        c_color.g *= other.g # type: ignore
-        c_color.b *= other.b # type: ignore
-        self.__dict__ = c_color.to_mode(self.mode).__dict__
+        self.r *= other.r
+        self.g *= other.g
+        self.b *= other.b
         return self
 
     def __itruediv__(self, other) -> "Color":
         other = Color.__normalize__(other)
-        c_color = self.to_rgb()
-        c_color.r **= other.r # type: ignore
-        c_color.g **= other.g # type: ignore
-        c_color.b **= other.b # type: ignore
-        self.__dict__ = c_color.to_mode(self.mode).__dict__
+        self.r **= other.r
+        self.g **= other.g
+        self.b **= other.b
         return self
     
     def __imod__(self, other) -> "Color":
         other = Color.__normalize__(other)
-        c_color = self.to_rgb()
-        c_color.r %= other.r # type: ignore
-        c_color.g %= other.g # type: ignore
-        c_color.b %= other.b # type: ignore
-        self.__dict__ = c_color.to_mode(self.mode).__dict__
+        self.r %= other.r
+        self.g %= other.g
+        self.b %= other.b
         return self
     
     def __ipow__(self, other) -> "Color":
         other = Color.__normalize__(other)
-        c_color = self.to_rgb()
-        c_color.r /= other.r # type: ignore
-        c_color.g /= other.g # type: ignore
-        c_color.b /= other.b # type: ignore
-        self.__dict__ = c_color.to_mode(self.mode).__dict__
+        self.r /= other.r
+        self.g /= other.g
+        self.b /= other.b
         return self
 
     def __ifloordiv__(self, other) -> "Color":
         other = Color.__normalize__(other)
-        c_color = self.to_rgb()
-        c_color.r //= other.r # type: ignore
-        c_color.g //= other.g # type: ignore
-        c_color.b //= other.b # type: ignore
-        self.__dict__ = c_color.to_mode(self.mode).__dict__
+        self.r //= other.r
+        self.g //= other.g
+        self.b //= other.b
         return self
 
     # comparasion
     def __eq__(self, other) -> bool:
         try: other = Color.__normalize__(other)
         except: return False
-        c_color = self.to_rgb()
-        return c_color.r == other.r and c_color.g == other.g and c_color.b == other.b # type: ignore
+        return self.r == other.r and self.g == other.g and self.b == other.b
 
     def __ne__(self, other) -> bool:
         return not self.__eq__(other)
 
     def __abs__(self) -> "Color":
-        c_color = self.to_rgb()
-        return Color(abs(c_color.r), abs(c_color.g), abs(c_color.b)).to_mode(self.mode) # type: ignore
+        self = self.to_rgb()
+        return Color(abs(self.r), abs(self.g), abs(self.b))
 
     def __round__(self, n=1) -> "Color":
         n = Color.__normalize__(n)
-        c_color = self.to_rgb()
-        return Color(round(c_color.r / n.r) * n.r, round(c_color.g / n.g) * n.g, round(c_color.b / n.b) * n.b).to_mode(self.mode) # type: ignore
+        return Color(round(self.r / n.r) * n.r, round(self.g / n.g) * n.g, round(self.b / n.b) * n.b)
 
     def __floor__(self, n=1) -> "Color":
         n = Color.__normalize__(n)
-        c_color = self.to_rgb()
-        return Color((c_color.r / n.r).__floor__() * n.r, (c_color.g / n.g).__floor__() * n.g, (c_color.b / n.b).__floor__() * n.b).to_mode(self.mode) # type: ignore
+        return Color((self.r / n.r).__floor__() * n.r, (self.g / n.g).__floor__() * n.g, (self.b / n.b).__floor__() * n.b)
 
     def __ceil__(self, n=1) -> "Color":
         n = Color.__normalize__(n)
-        c_color = self.to_rgb()
-        return Color((c_color.r / n.r).__ceil__() * n.r, (c_color.g / n.g).__ceil__() * n.g, (c_color.b / n.b).__ceil__() * n.b).to_mode(self.mode) # type: ignore
+        return Color((self.r / n.r).__ceil__() * n.r, (self.g / n.g).__ceil__() * n.g, (self.b / n.b).__ceil__() * n.b)
     
     def __float__(self) -> "Color":
-        c_color = self.to_rgb()
-        return Color(float(c_color.r), float(c_color.g), float(c_color.b)).to_mode(self.mode) # type: ignore
+        return Color(float(self.r), float(self.g), float(self.b))
 
     def __getitem__(self, n) -> int|float:
         return self.values[n] if isinstance(n, int) else self.values[self.keys.index(n)]
@@ -432,6 +397,8 @@ class Color:
     def __normalize__(cls, other) -> "Color":
         if isinstance(other, Color):
             return other
+        if isinstance(other, __color_pygame__):
+            return cls(*other[:], mode="rgba")
         if isinstance(other, (int, float)):
             return cls(other, other, other)
         if isinstance(other, (list, tuple)):
@@ -459,8 +426,15 @@ class Color:
     def randomize(cls) -> "Color":
         return Color(__randint__(0,255), __randint__(0,255), __randint__(0,255))
 
-WHITE_COLOR_PYG = Color.white()()
-BLACK_COLOR_PYG = Color.black()()
-RED_COLOR_PYG = Color.red()()
-GREEN_COLOR_PYG = Color.green()()
-BLUE_COLOR_PYG = Color.blue()()
+
+WHITE_COLOR = Color.white()
+BLACK_COLOR = Color.black()
+RED_COLOR = Color.red()
+GREEN_COLOR = Color.green()
+BLUE_COLOR = Color.blue()
+
+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()

{e2d-1.4.17 → e2d-1.4.19}/e2D/envs.py

@@ -76,7 +76,7 @@ class RootEnv:
 
     @property
     def delta(self) -> int:
-        return self.clock.get_time()
+        return self.clock.get_time() / 1000
 
     def get_teoric_max_fps(self) -> float:
         rawdelta = self.clock.get_rawtime()

{e2d-1.4.17 → e2d-1.4.19}/e2D/plots.py

@@ -50,7 +50,7 @@ class Object:
         self.plot.canvas.blit(self.__layer_surface__, (0,0))
 
 class Line(Object):
-    def __init__(self, id:int|str, point_a:Vector2D|Point, point_b:Vector2D|Point, color:list[float]|tuple[float,float,float]=(255,255,255), width:float=1) -> None:
+    def __init__(self, id:int|str, point_a:Vector2D|Point, point_b:Vector2D|Point, color:pg.Color=WHITE_COLOR_PYG, width:float=1) -> None:
         super().__init__()
         self.id = id
         if isinstance(point_a, Point):
@@ -79,13 +79,13 @@ class Point(Object):
                 position : Vector2D,
                 label : str = "",
                 radius : float = 1,
-                color : list[float]|tuple[float,float,float] = (255,255,255),
-                label_color : tuple[float, float, float] = (255, 255, 255),
+                color : pg.Color = WHITE_COLOR_PYG,
+                label_color : pg.Color = WHITE_COLOR_PYG,
                 label_position_offset : Vector2D = Vector2D.zero(),
                 label_pivot_position : __LITERAL_PIVOT_POSITIONS__ = "top_left",
                 label_font : pg.font.Font = FONT_ARIAL_32,
-                label_bg_color : tuple[int,int,int]|list[int]|None = None,
-                label_border_color : tuple[int,int,int]|list[int]|None = None,
+                label_bg_color : pg.Color|None = None,
+                label_border_color : pg.Color|None = None,
                 label_border_width : float = 0,
                 label_border_radius : int|list[int]|tuple[int,int,int,int] = -1,
                 label_margin : Vector2D = Vector2D.zero()
@@ -128,7 +128,7 @@ class MathFunction(Function):
                  function:Callable[[np.ndarray, np.ndarray], np.ndarray],
                  domain:list[float]=[-np.inf, np.inf],
                  codomain:list[float]=[-np.inf, np.inf],
-                 color:list[float]|tuple[float,float,float]=(255,255,255)) -> None:
+                 color:pg.Color=WHITE_COLOR_PYG) -> None:
         super().__init__()
         self.id = id
         self.color = color
@@ -162,7 +162,7 @@ class MathFunction(Function):
             self.points = self.get_points()
             self.__render__()
     
-    def get_derivative(self, delta:float=.01, color:None|list[float]|tuple[float,float,float]=None) -> MathFunction:
+    def get_derivative(self, delta:float=.01, color:None|pg.Color=None) -> MathFunction:
         return MathFunction(lambda x,y: (self.function(x + delta, y) - self.function(x,y))/delta - y, color if color != None else self.color) #type: ignore
 
     def __render__(self) -> None:
@@ -181,7 +181,7 @@ class MathFunction(Function):
                 self.__layer_surface__.set_at(point, self.color) #type: ignore
 
 class TimeFunction(Function):
-    def __init__(self, id:int|str, function, t_range:list[float]=[0,0, 1.0], t_step:float=.01, color:list[float]|tuple[float,float,float]=(255,255,255)) -> None:
+    def __init__(self, id:int|str, function, t_range:list[float]=[0,0, 1.0], t_step:float=.01, color:pg.Color=WHITE_COLOR_PYG) -> None:
         super().__init__()
         self.id = id
         self.color = color
@@ -222,7 +222,7 @@ class TimeFunction(Function):
                 self.__layer_surface__.set_at(point, self.color) #type: ignore
 
 class PointsFunction(Function):
-    def __init__(self, id:int|str, points:list[Vector2D]=[], points_color:list[float]|tuple[float,float,float]=(255,0,0), color:list[float]|tuple[float,float,float]=(255,255,255)) -> None:
+    def __init__(self, id:int|str, points:list[Vector2D]=[], points_color:pg.Color=RED_COLOR_PYG, color:pg.Color=WHITE_COLOR_PYG) -> None:
         super().__init__()
         self.id = id
         self.color = color
@@ -251,7 +251,7 @@ def no_error_complex_function(function, args) -> Vector2D:
     return Vector2D(res.real, res.imag)
 sign = lambda value: -1 if value < 0 else (1 if value > 0 else 0)
 class ComplexFunction:
-    def __init__(self, function, plot:"Plot", starting_t:float=-10, ending_t:float=10, step=.01, color=(255,255,255), auto_connect_treshold=float("inf"), points_radius=2, points_color=None) -> None:
+    def __init__(self, function, plot:"Plot", starting_t:float=-10, ending_t:float=10, step=.01, color=WHITE_COLOR_PYG, auto_connect_treshold=float("inf"), points_radius=2, points_color=None) -> None:
         self.auto_connect_treshold = auto_connect_treshold
         self.plot = plot
         self.starting_t = starting_t
@@ -288,7 +288,7 @@ class ComplexFunction:
 class __PlotSettings__:
     def __init__(self, plot:Plot) -> None:
         self.plot = plot
-        self.settings :dict[__LITERAL_SETTINGS_KEYS__, int|float|bool|Vector2D|tuple|list|pg.font.Font]= {
+        self.settings :dict[__LITERAL_SETTINGS_KEYS__, int|float|bool|Vector2D|pg.Color|pg.font.Font]= {
             # axes
                 "distance_to_axis_for_scalar_zoom" : 10,
 
@@ -305,11 +305,11 @@ class __PlotSettings__:
                 
                 # axes
                     "change_axes_colors_on_mouse_hover" : True,
-                    "mouse_hover_axes_color" : rgb(200, 200, 200),
+                    "mouse_hover_axes_color" : Color(200, 200, 200)(),
                     "show_axes" : True,
                     "show_x_axis" : True,
                     "show_y_axis" : True,
-                    "axes_default_color" : rgb(100, 100, 100),
+                    "axes_default_color" : Color(100, 100, 100)(),
                     "x_axis_color" : None,
                     "y_axis_color" : None,
                     "axes_default_width" : 5,
@@ -320,22 +320,22 @@ class __PlotSettings__:
                 # grid
                     "show_grid" : True,
                     "grid_step" : Vector2D(PI, 1),
-                    "grid_color" : rgb(17, 65, 68),
+                    "grid_color" : Color(17, 65, 68)(),
                     "grid_width" : 1,
             
                 # pointer
                     "show_pointer" : True,
                     "pointer_radius" : 15,
-                    "pointer_color" : rgb(255, 255, 255),
+                    "pointer_color" : WHITE_COLOR_PYG,
                 
                 # cursor
                     "show_cursor_coords" : False,
 
                 # rect
                     "render_bg" : True,
-                    "bg_color" : rgb(28, 29, 34),
+                    "bg_color" : Color(28, 29, 34)(),
                     "draw_rect" : True,
-                    "rect_color" : rgb(255, 255, 255),
+                    "rect_color" : WHITE_COLOR_PYG,
                     "rect_width" : 5,
                     "show_corners_coords" : True,
 
@@ -364,17 +364,17 @@ class __PlotSettings__:
     def toggle(self, key:__LITERAL_SETTINGS_KEYS__) -> None:
         self.set(key, not self.get(key))
 
-    def set(self, key:__LITERAL_SETTINGS_KEYS__, new_value:int|float|bool|Vector2D|tuple|list|pg.font.Font) -> None:
+    def set(self, key:__LITERAL_SETTINGS_KEYS__, new_value:int|float|bool|Vector2D|pg.Color|pg.font.Font) -> None:
         if not (key in self.settings): raise ValueError(f"The key [{key}] does not exist...")
         self.settings[key] = new_value
 
-    def multiple_set(self, new_key_and_values_dict:dict[__LITERAL_SETTINGS_KEYS__, int|float|bool|Vector2D|tuple|list|pg.font.Font]) -> None:
+    def multiple_set(self, new_key_and_values_dict:dict[__LITERAL_SETTINGS_KEYS__, int|float|bool|Vector2D|pg.Color|pg.font.Font]) -> None:
         self.settings.update(new_key_and_values_dict)
     
-    def get(self, key:__LITERAL_SETTINGS_KEYS__) -> int|float|bool|Vector2D|tuple|list|pg.font.Font:
+    def get(self, key:__LITERAL_SETTINGS_KEYS__) -> int|float|bool|Vector2D|pg.Color|pg.font.Font:
         return self.settings[key]
 
-    def multiple_get(self, keys:list[__LITERAL_SETTINGS_KEYS__]) -> list[int|float|bool|Vector2D|tuple|list|pg.font.Font]:
+    def multiple_get(self, keys:list[__LITERAL_SETTINGS_KEYS__]) -> list[int|float|bool|Vector2D|pg.Color|pg.font.Font]:
         return [self.get(key) for key in keys]
 
 class Plot:
@@ -483,10 +483,10 @@ class Plot:
             pg.draw.circle(self.canvas, pointer_color, (self.size * .5)(), 15, 1) #type: ignore
 
         if self.settings.get("show_corners_coords"):
-            self.rootEnv.print(self.top_left_plot_coord.advanced_stringify(4, True), Vector2D.zero(), bg_color=(0,0,0), border_color=(255,255,255), border_width=2, border_radius=15, margin=Vector2D(10,10), personalized_surface=self.canvas)
-            self.rootEnv.print(Vector2D(self.top_left_plot_coord.x, self.bottom_right_plot_coord.y).advanced_stringify(4, True), self.size * Vector2D(0, 1), pivot_position="bottom_left", bg_color=(0,0,0), border_color=(255,255,255), border_width=2, border_radius=15, margin=Vector2D(10,10), personalized_surface=self.canvas)
-            self.rootEnv.print(self.bottom_right_plot_coord.advanced_stringify(4, True), self.size.copy, pivot_position="bottom_right", bg_color=(0,0,0), border_color=(255,255,255), border_width=2, border_radius=15, margin=Vector2D(10,10), personalized_surface=self.canvas)
-            self.rootEnv.print(Vector2D(self.bottom_right_plot_coord.x, self.top_left_plot_coord.y).advanced_stringify(4, True), self.size * Vector2D(1, 0), pivot_position="top_right", bg_color=(0,0,0), border_color=(255,255,255), border_width=2, border_radius=15, margin=Vector2D(10,10), personalized_surface=self.canvas)
+            self.rootEnv.print(self.top_left_plot_coord.advanced_stringify(4, True), Vector2D.zero(), bg_color=BLACK_COLOR_PYG, border_color=WHITE_COLOR_PYG, border_width=2, border_radius=15, margin=Vector2D(10,10), personalized_surface=self.canvas)
+            self.rootEnv.print(Vector2D(self.top_left_plot_coord.x, self.bottom_right_plot_coord.y).advanced_stringify(4, True), self.size * Vector2D(0, 1), pivot_position="bottom_left", bg_color=BLACK_COLOR_PYG, border_color=WHITE_COLOR_PYG, border_width=2, border_radius=15, margin=Vector2D(10,10), personalized_surface=self.canvas)
+            self.rootEnv.print(self.bottom_right_plot_coord.advanced_stringify(4, True), self.size.copy, pivot_position="bottom_right", bg_color=BLACK_COLOR_PYG, border_color=WHITE_COLOR_PYG, border_width=2, border_radius=15, margin=Vector2D(10,10), personalized_surface=self.canvas)
+            self.rootEnv.print(Vector2D(self.bottom_right_plot_coord.x, self.top_left_plot_coord.y).advanced_stringify(4, True), self.size * Vector2D(1, 0), pivot_position="top_right", bg_color=BLACK_COLOR_PYG, border_color=WHITE_COLOR_PYG, border_width=2, border_radius=15, margin=Vector2D(10,10), personalized_surface=self.canvas)
     
     def update(self) -> None:
         # update mouse and center positions

{e2d-1.4.17 → e2d-1.4.19}/e2D.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: e2D
-Version: 1.4.17
+Version: 1.4.19
 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.17 → e2d-1.4.19}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = e2D
-version = 1.4.17
+version = 1.4.19
 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!