e2D 1.4.16__tar.gz → 1.4.18__tar.gz

{e2d-1.4.16 → e2d-1.4.18}/PKG-INFO

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

@@ -17,7 +17,7 @@ class Vector2D:
         self.x = x
         self.y = y
 
-    def distance_to(self, other, rooted=True) -> int|float:
+    def distance_to(self, other, rooted=True) -> float:
         d = (self.x - other.x)**2 + (self.y - other.y)**2
         return d**(1/2) if rooted else d
 
@@ -56,6 +56,10 @@ class Vector2D:
     @property
     def length_sqrd(self) -> float:
         return self.x ** 2 + self.y ** 2
+    
+    @property
+    def inverse(self) -> "Vector2D":
+        return self.mult(-1)
 
     def floor(self, n=1) -> "Vector2D":
         return self.__floor__(n)
@@ -494,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.16 → e2d-1.4.18}/e2D/__init__.pyi

@@ -39,7 +39,7 @@ class Vector2D:
         self.x : int|float
         self.y : int|float
 
-    def distance_to(self:"Vector2D", other:"Vector2D", rooted:bool=True) -> int|float:
+    def distance_to(self:"Vector2D", other:"Vector2D", rooted:bool=True) -> float:
         """
         # Calculate the distance between the current Vector2D other and another other.
 
@@ -249,6 +249,10 @@ class Vector2D:
     @property
     def length_sqrd(self:"Vector2D") -> float:
         ...
+    
+    @property
+    def inverse(self:"Vector2D") -> "Vector2D":
+        ...
 
     def floor(self:"Vector2D", n:"int|float|Vector2D"=1) -> "Vector2D":
         ...
@@ -796,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.16 → e2d-1.4.18}/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)):
@@ -451,13 +418,23 @@ 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))
 
-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()