e2D 1.4.0__tar.gz → 1.4.2__tar.gz

{e2D-1.4.0 → e2D-1.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: e2D
-Version: 1.4.0
+Version: 1.4.2
 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.0 → e2D-1.4.2}/e2D/__init__.py

@@ -17,260 +17,36 @@ DOUBLE_PI = PI*2
 class Vector2D:
     round_values_on_print :int|float= 2
     def __init__(self:"V2|Vector2D", x:int|float=0.0, y:int|float=0.0) -> None:
-        """
-        # Initialize a 2D vector with the specified x and y components.
-
-        ## Parameters:
-            x (int | float, optional): The x-component of the vector. Default is 0.
-            y (int | float, optional): The y-component of the vector. Default is 0.
-
-        ## Example:
-            vector1 = Vector2D()        # Creates a vector with x=0 and y=0
-            vector2 = Vector2D(3, -2.5) # Creates a vector with x=3 and y=-2.5
-
-        ## Explanation:
-            This constructor initializes a 2D vector with the specified x and y components.
-
-            If no arguments are provided, the default values for x and y are both set to 0.
-
-            The x and y components can be integers or floating-point numbers.
-
-            Example usage is shown in the "Example" section above.
-        """
         self.x = x
         self.y = y
     
     def set(self:"V2|Vector2D", x:int|float=0, y:int|float=0) -> None:
-        """
-        # Change the components of the Vector2D other without creating a new one.
-
-        ## Parameters:
-            x (int | float, optional): The new x-component to set. Default is 0.
-            y (int | float, optional): The new y-component to set. Default is 0.
-
-        ## Example:
-            vector = Vector2D(1, 2)
-            vector.set(3, -4)
-            print(vector.x, vector.y)  # Output: 3, -4
-
-        ## Explanation:
-            The method updates the x and y components of the Vector2D other to the specified values.
-
-            If no arguments are provided, the default values for x and y are both set to 0.
-
-            The x and y components can be integers or floating-point numbers.
-
-            The method does not return any value, but it modifies the Vector2D other in place.
-
-            Example usage is shown in the "Example" section above.
-        """
         self.x = x
         self.y = y
 
     def distance_to(self:"V2|Vector2D", other:"float|int|Vector2D|V2|list|tuple", sqrd:bool=True) -> int|float:
-        """
-        # Calculate the distance between the current Vector2D other and another other.
-
-        ## Parameters:
-            other (float or int or Vector2D or list|tuple): The other other to which the distance is calculated.
-            squared (bool, optional): If True, return the squared distance. If False, return the actual distance.
-                                      Default is True.
-
-        ## Returns:
-            int|float: The squared distance between the current Vector2D other and the other other if `squared` is True,
-                      otherwise the actual distance.
-
-        ## Example:
-            point1 = Vector2D(0, 0)
-
-            point2 = Vector2D(3, 4)
-
-            squared_distance = point1.distance_to(point2)
-
-            print(f"Squared Distance: {squared_distance}")
-
-            distance = point1.distance_to(point2, squared=False)
-
-            print(f"Actual Distance: {distance}")
-
-            This will calculate the squared and actual distances between the two points.
-
-        ## Explanation:
-            The function calculates the squared distance between the current Vector2D other (self) and another other
-            (other) using the formula: (self.x - other.x)**2 + (self.y - other.y)**2.
-
-            The result is returned as the squared distance if `squared` is True, or as the actual distance if `squared` is False.
-        """
         other = self.__normalize__(other)
         d = (self.x - other.x)**2 + (self.y - other.y)**2
         return (d**(1/2) if sqrd else d)
 
     def angle_to(self:"V2|Vector2D", other:"float|int|Vector2D|V2|list|tuple") -> int|float:
-        """
-        # Calculate the angle between the current Vector2D other and another other.
-
-        ## Parameters:
-            other (float or int or Vector2D or list|tuple): The other other to which the angle is calculated.
-
-        ## Returns:
-            int|float: The angle in radians between the current Vector2D other and the other other.
-
-        ## Example:
-            point1 = Vector2D(0, 0)
-
-            point2 = Vector2D(1, 1)
-
-            angle = point1.angle_to(point2)
-
-            print(f"Angle in radians: {angle}")
-
-            This will calculate the angle in radians between the two points.
-
-        ## Explanation:
-            The function calculates the angle in radians between the current Vector2D other (self) and another other
-            (other) using the `atan2` function from the `math` module.
-
-            The result is returned as the angle in radians.
-        """
         other = self.__normalize__(other)
         return _mt.atan2(other.y - self.y, other.x - self.x)
 
     def point_from_degs(self:"V2|Vector2D", degs:int|float, radius:int|float) -> "Vector2D|V2":
-        """
-        # Calculate a new Vector2D point from the current point based on an angle in degs and a radius.
-
-        ## Parameters:
-            rad (int|float): The angle in degs.
-            radius (int|float): The distance from the current point.
-
-        ## Returns:
-            Vector2D: A new Vector2D point calculated from the current point.
-
-        ## Example:
-            point1 = Vector2D(0, 0)
-
-            angle = 45
-
-            distance = 5
-
-            new_point = point1.point_from_degs(angle, distance)
-
-            print(new_point.x, new_point.y)
-
-            This will calculate a new point 5 units away from point1 at a 45-degree angle.
-
-        ## Explanation:
-            The function calculates a new Vector2D point based on an angle in degs (degs) and a distance (radius)
-            from the current Vector2D point.
-
-            It computes the new x and y coordinates of the point using the trigonometric functions `cos` and `sin`
-            to determine the horizontal and vertical components of the new point.
-
-            The result is returned as a new Vector2D point with the calculated coordinates.
-        """
         x = radius * _mt.cos(_mt.radians(degs)) + self.x
         y = radius * _mt.sin(_mt.radians(degs)) + self.y
         return Vector2D(x, y)
     
     def point_from_rads(self:"V2|Vector2D", rad:int|float, radius:int|float) -> "Vector2D|V2":
-        """
-        # Calculate a new Vector2D point from the current point based on an angle in radians and a radius.
-
-        ## Parameters:
-            rad (int|float): The angle in radians.
-            radius (int|float): The distance from the current point.
-
-        ## Returns:
-            Vector2D: A new Vector2D point calculated from the current point.
-
-        ## Example:
-            point1 = Vector2D(0, 0)
-
-            angle = 45
-
-            distance = 5
-
-            new_point = point1.point_from_degs(_mt.radians(angle), distance)
-
-            print(new_point.x, new_point.y)
-
-            This will calculate a new point 5 units away from point1 at a 45-degree angle.
-
-        ## Explanation:
-            The function calculates a new Vector2D point based on an angle in radians (rad) and a distance (radius)
-            from the current Vector2D point.
-
-            It computes the new x and y coordinates of the point using the trigonometric functions `cos` and `sin`
-            to determine the horizontal and vertical components of the new point.
-
-            The result is returned as a new Vector2D point with the calculated coordinates.
-        """
         x = radius * _mt.cos(rad) + self.x
         y = radius * _mt.sin(rad) + self.y
         return Vector2D(x, y)
 
     def copy(self:"V2|Vector2D") -> "Vector2D|V2":
-        """
-        # Create a copy of the current Vector2D other.
-
-        ## Returns:
-            Vector2D: A new Vector2D other with the same x and y coordinates as the current other.
-
-        ## Example:
-            point1 = Vector2D(1, 2)
-
-            point2 = point1.copy()
-
-            print(point2.x, point2.y)
-
-            This will print the x and y coordinates of the copied Vector2D other (1, 2).
-
-        ## Explanation:
-            The function creates a new Vector2D other with the same x and y coordinates as the current other.
-
-            The result is returned as a new Vector2D other, effectively making a copy of the original other.
-        """
         return Vector2D(self.x, self.y)
 
     def sign(self:"V2|Vector2D") -> "Vector2D|V2":
-        """
-        # Perform an "absolute round" operation on the Vector2D other.
-
-        ## Parameters:
-            n (int|float, optional): The numeric value to scale the "absolute rounded" vector. Default is 1.
-
-        ## Returns:
-            Vector2D: The "absolute rounded" Vector2D other scaled by the provided numeric value.
-
-        ## Example:
-            vector1 = Vector2D(3.3, -4.7)
-
-            result1 = vector1.absolute_round(0.5)
-
-            print(result1.x, result1.y)
-
-            vector2 = Vector2D(-2.8, 1.1)
-
-            result2 = vector2.absolute_round()
-
-            print(result2.x, result2.y)
-
-        ## Explanation:
-            The function performs an "absolute round" operation on the Vector2D other.
-
-            The "absolute round" operation involves taking the absolute values of both the x and y components of the Vector2D other,
-            and then scaling the resulting vector by the provided numeric value (n).
-
-            The default value of n is 1, which means the "absolute rounded" vector will have the same magnitude as the original vector.
-
-            If the provided numeric value (n) is 0, the function returns a Vector2D other with zeros for both components.
-
-            If the provided numeric value (n) is negative, the resulting "absolute rounded" vector will point in the opposite direction
-            as the original vector but will have the same magnitude.
-
-            Note: The "absolute round" operation does not perform standard mathematical rounding; instead, it ensures the resulting
-            vector points in the same direction as the original vector but has non-negative components.
-        """
         return self.no_zero_div_error(abs(self), "zero")
 
     def floor(self:"V2|Vector2D", n:"int|float|Vector2D|V2"=1) -> "Vector2D|V2":
@@ -283,40 +59,6 @@ class Vector2D:
         return self.__round__(n)
 
     def randomize(start:"int|float|Vector2D|V2|None"=None, end:"int|float|Vector2D|V2|None"=None) -> "Vector2D|V2": #type: ignore
-        """
-        # Generate a random Vector2D point within the specified range.
-
-        ## Parameters:
-            start (int|float or Vector2D or None, optional): The starting point of the range.
-                                                        Default is None, which corresponds to (0, 0).
-                                                        If numeric, both x and y will have the same value.
-            end (int|float or Vector2D or None, optional): The ending point of the range.
-                                                        Default is None, which corresponds to (1, 1).
-                                                        If numeric, both x and y will have the same value.
-
-        ## Returns:
-            Vector2D: A new random Vector2D point within the specified range.
-
-        ## Example:
-            random_point = randomize(Vector2D(10, 20), Vector2D(50, 70))
-
-            print(random_point.x, random_point.y)
-
-            This will print a random point between (10, 20) and (50, 70).
-
-        ## Explanation:
-            The function generates a random Vector2D point within the specified range defined by `start` and `end`.
-
-            If `start` and `end` are numeric values (int or float), both x and y coordinates will have the same value.
-
-            If `start` and `end` are None, the default range is assumed to be (0, 0) to (1, 1).
-
-            The function first checks if `start` and `end` are Vector2D others. If not, it creates new Vector2D others
-            based on the numeric values provided or the default values.
-
-            It then generates random x and y coordinates in the range [0, 1) using the `random()` function from the `random` module.
-            These random values are then scaled by (end - start) and added to the start point to obtain the final random Vector2D point.
-        """
         if not any(isinstance(start, cls) for cls in {Vector2D, V2}):
             if type(start) in int|float: start = Vector2D(start, start) #type: ignore
             elif type(start) == None: start = Vector2D(0,0)
@@ -329,100 +71,15 @@ class Vector2D:
     
     def dot_product(self, other:"float|int|Vector2D|V2|list|tuple") -> float:
         other = self.__normalize__(other)
-        """
-        # Calculate the dot product of the current vector with another vector.
-
-        ## Parameters:
-            other (Vector2D): The other vector for the dot product calculation.
-
-        ## Returns:
-            float: The dot product value.
-
-        ## Example:
-            v1 = Vector2D(2, 3)
-            v2 = Vector2D(4, -1)
-            result = v1.dot_product(v2)
-            print(result)  # Output: 5
-
-        ## Explanation:
-            The dot product of two vectors (A and B) is given by the formula: dot_product = A.x * B.x + A.y * B.y
-
-            The method takes another vector (other) as input and returns the dot product value.
-
-            Example usage is shown in the "Example" section above.
-        """
         return self.x * other.x + self.y * other.y
 
     def normalize(self) -> "Vector2D":
-        """
-        # Vector Normalization
-
-        ## Returns:
-            Vector2D: A new vector with the same direction as the current vector but with a magnitude of 1.
-
-        ## Raises:
-            ValueError: If the magnitude of the current vector is zero (zero vector).
-
-        ## Example:
-            v = Vector2D(3, 4)
-            normalized_v = v.normalize()  # Normalize the vector (3, 4)
-            print(normalized_v)  # Output: (0.6, 0.8)
-
-        ## Explanation:
-            This method calculates the normalized version of the current vector, which means a new vector with the same direction as the original but with a magnitude of 1.
-
-            The method first calculates the magnitude of the current vector using the 'magnitude' method.
-
-            If the magnitude is zero (zero vector), a ValueError is raised, as normalization is not defined for zero vectors.
-
-            The normalized vector is obtained by dividing each component of the current vector by its magnitude.
-
-            The resulting normalized vector is returned.
-
-            Example usage is shown in the "Example" section above.
-        """
         mag = self.length()
         if mag == 0:
             return self
         return Vector2D(self.x / mag, self.y / mag)
 
     def projection(self, other:"float|int|Vector2D|V2|list|tuple") -> "Vector2D|V2":
-        """
-        # Vector Projection
-
-        ## Parameters:
-            other (float, int, Vector2D, V2, list, tuple): The vector onto which to project.
-
-        ## Returns:
-            Vector2D or V2: The projection of the current vector onto the 'other' vector.
-
-        ## Raises:
-            ValueError: If 'other' is a zero vector.
-
-        ## Example:
-            v1 = Vector2D(3, 4)
-            v2 = Vector2D(1, 0)
-            projection_v = v1.projection(v2)  # Calculate the projection of v1 onto v2
-            print(projection_v)  # Output: (3.0, 0.0)
-
-        ## Explanation:
-            This method calculates the projection of the current vector onto the 'other' vector.
-            The projection is a vector that represents the component of the current vector in the direction of the 'other' vector.
-
-            If 'other' is not a Vector2D instance, it will be converted to one using the '__normalize__' method.
-            The method first normalizes the 'other' vector using the '__normalize__' method of the vector.
-
-            Next, it calculates the dot product of the current vector and the normalized 'other' vector using the 'dot_product' method.
-            It also calculates the squared magnitude of the 'other' vector using the 'magnitude' method.
-
-            If the magnitude of 'other' is zero (a zero vector), a ValueError is raised, as projection is not defined for zero vectors.
-
-            The projection is then obtained by scaling the 'other' vector by the dot product divided by the squared magnitude.
-
-            The resulting projection vector is returned.
-
-            Example usage is shown in the "Example" section above.
-        """
         other = self.__normalize__(other)
         dot_product = self.dot_product(other)
         magnitude_product = other.length() ** 2
@@ -431,90 +88,17 @@ class Vector2D:
         return other * (dot_product / magnitude_product)
 
     def reflection(self, normal:"float|int|Vector2D|V2|list|tuple") -> "Vector2D|V2":
-        """
-        # Vector Reflection
-
-        ## Parameters:
-            normal (float, int, Vector2D, V2, list, tuple): The normal vector representing the surface of reflection.
-
-        ## Returns:
-            Vector2D or V2: The reflected vector.
-
-        ## Example:
-            incident_vector = Vector2D(3, 4)
-            normal_vector = Vector2D(1, 0)
-            reflected_vector = incident_vector.reflection(normal_vector)  # Calculate the reflection of the incident vector over the given normal
-            print(reflected_vector)  # Output: (-3.0, 4.0)
-
-        ## Explanation:
-            This method calculates the reflection of the current vector over the given normal vector.
-            The normal vector represents the surface of reflection, and it should be normalized (unit vector).
-
-            The method first normalizes the 'normal' vector using the '__normalize__' method of the vector.
-            Next, it calculates the projection of the current vector onto the 'normal' vector using the 'projection' method.
-            The reflected vector is obtained by subtracting twice the projection from the current vector.
-
-            The resulting reflected vector is returned.
-
-            Example usage is shown in the "Example" section above.
-        """
         normal = self.__normalize__(normal)
         projection = self.projection(normal)
         return self - projection * 2
 
     def cartesian_to_polar(self) -> tuple:
-        """
-        # Convert Cartesian Coordinates to Polar Coordinates
-
-        ## Returns:
-            tuple: A tuple containing the radial distance (magnitude) 'r' and the angle 'theta' in radians.
-
-        ## Example:
-            v = Vector2D(3, 4)
-            r, theta = v.cartesian_to_polar()  # Convert Cartesian coordinates (3, 4) to polar
-            print(r, theta)  # Output: (5.0, 0.9272952180016122)
-
-        ## Explanation:
-            This method converts Cartesian coordinates (x, y) to polar coordinates (r, theta).
-            'r' is the radial distance (magnitude) from the origin to the point, and 'theta' is the angle
-            (in radians) measured from the positive x-axis to the point.
-
-            The method calculates the radial distance 'r' using the 'magnitude' method of the vector.
-            The angle 'theta' is calculated using the arctan2 function, which takes the y and x components of the vector.
-
-            The resulting 'r' and 'theta' are returned as a tuple.
-
-            Example usage is shown in the "Example" section above.
-        """
         r = self.length()
         theta = _mt.atan2(self.y, self.x)
         return r, theta
 
     @classmethod
     def polar_to_cartesian(cls, r: float|int, theta: float|int) -> "Vector2D|V2":
-        """
-        # Convert Polar Coordinates to Cartesian Coordinates
-
-        ## Parameters:
-            r (float or int): The radial distance (magnitude) from the origin to the point.
-            theta (float or int): The angle (in radians or degrees) measured from the positive x-axis to the point.
-
-        ## Returns:
-            Vector2D or V2: A new vector representing the Cartesian coordinates (x, y) of the point.
-
-        ## Example:
-            cartesian_point = Vector2D.polar_to_cartesian(5, math.pi/4)  # Convert polar coordinates (r=5, theta=45 degrees) to Cartesian
-            print(cartesian_point)  # Output: (3.5355339059327378, 3.5355339059327373)
-
-        ## Explanation:
-            This class method converts polar coordinates (r, theta) to Cartesian coordinates (x, y).
-            'r' is the radial distance (magnitude) from the origin to the point, and 'theta' is the angle
-            (in radians or degrees) measured from the positive x-axis to the point.
-
-            The method calculates the x and y components using trigonometric functions (cosine and sine) based on 'r' and 'theta'.
-
-            Example usage is shown in the "Example" section above.
-        """
         x = r * _mt.cos(theta)
         y = r * _mt.sin(theta)
         return cls(x, y)
@@ -530,74 +114,12 @@ class Vector2D:
         return (self.x ** 2 + self.y ** 2) ** .5
 
     def lerp(self, other:"float|int|Vector2D|V2|list|tuple", t: float) -> "Vector2D|V2":
-        """
-        # Linear Interpolation (LERP)
-
-        ## Parameters:
-            other (float, int, Vector2D, V2, list, tuple): The vector to interpolate towards.
-            t (float): The interpolation parameter. Must be between 0 and 1.
-
-        ## Returns:
-            Vector2D or V2: The result of the linear interpolation.
-
-        ## Raises:
-            ValueError: If t is not within the range [0, 1].
-
-        ## Example:
-            v1 = Vector2D(1, 2)
-            v2 = Vector2D(5, 7)
-            interpolated_v = v1.lerp(v2, 0.5)  # Linearly interpolate between v1 and v2 with t = 0.5
-            print(interpolated_v)  # Output: (3.0, 4.5)
-
-        ## Explanation:
-            This method performs linear interpolation between the current vector and the 'other' vector.
-            The 't' parameter represents the interpolation parameter, which controls how much the interpolation
-            leans towards the 'other' vector. When 't' is 0, the result will be equal to the current vector (self).
-            When 't' is 1, the result will be equal to the 'other' vector. For intermediate values of 't', the
-            result will be a linear combination of the two vectors, smoothly transitioning between them.
-
-            If 'other' is not a Vector2D instance, it will be converted to one using the '__normalize__' method.
-            If 't' is not within the range [0, 1], a ValueError is raised.
-
-            Example usage is shown in the "Example" section above.
-        """
         other = self.__normalize__(other)
         if not 0 <= t <= 1:
             raise ValueError("t must be between 0 and 1 for linear interpolation.")
         return Vector2D(self.x + (other.x - self.x) * t, self.y + (other.y - self.y) * t)
 
     def rotate(self, angle: int|float, center:"float|int|Vector2D|V2|list|tuple|None"=None) -> "Vector2D|V2":
-        """
-        # Rotate the vector by a given angle around the origin or a specified center.
-
-        ## Parameters:
-            angle (int or float): The angle of rotation in radians or degrees, depending on the trigonometric functions used.
-            center (float, int, Vector2D, V2, list, tuple, or None): The center of rotation.
-                If None, the vector is rotated around the origin (0, 0).
-
-        ## Returns:
-            Vector2D or V2: The rotated vector.
-
-        ## Example:
-            v = Vector2D(3, 4)
-            rotated_v = v.rotate(math.pi / 4)  # Rotate 45 degrees around the origin
-            print(rotated_v)  # Output: (0.7071067811865476, 5.656854249492381)
-            
-            center = Vector2D(1, 1)
-            rotated_v = v.rotate(math.pi / 4, center)  # Rotate 45 degrees around the center (1, 1)
-            print(rotated_v)  # Output: (1.7071067811865475, 2.656854249492381)
-
-        ## Explanation:
-            This method rotates the vector by the specified angle around the given center.
-            If no center is provided, the vector is rotated around the origin (0, 0).
-
-            The method calculates the trigonometric functions (cosine and sine) of the angle to perform the rotation.
-            The translated vector is obtained by subtracting the center from the current vector.
-            The rotated vector is then obtained by applying the rotation transformation to the translated vector.
-            The center is added back to the rotated vector to obtain the final result.
-
-            Example usage is shown in the "Example" section above.
-        """
         if center is None: center = V2z
         else: center = self.__normalize__(center)
         translated = self - center
@@ -606,48 +128,6 @@ class Vector2D:
         return Vector2D(translated.x * cos_angle - translated.y * sin_angle, translated.x * sin_angle + translated.y * cos_angle) + center
 
     def no_zero_div_error(self:"Vector2D|V2", n:"int|float|Vector2D|V2", error_mode:str="zero") -> "Vector2D|V2":
-        """
-        # Handle division between the Vector2D other and a numeric value or another Vector2D other.
-
-        ## Parameters:
-            n (int|float or Vector2D): The numeric value or Vector2D other for division.
-            error_mode (str, optional): The mode to handle division by zero scenarios.
-                                        - "zero" (default): Return a Vector2D other with zeros for both components.
-                                        - "null": Return a Vector2D other with the original x or y component if available,
-                                                   otherwise, return NaN (Not a Number) for the component.
-
-        ## Returns:
-            Vector2D: A new Vector2D other after division or handling division by zero scenarios.
-
-        ## Example:
-            vector1 = Vector2D(3, 4)
-
-            result1 = vector1.no_zero_div_error(2)
-
-            print(result1.x, result1.y)
-
-            vector2 = Vector2D(5, 0)
-
-            result2 = vector1.no_zero_div_error(vector2, error_mode="null")
-
-            print(result2.x, result2.y)
-
-        ## Explanation:
-            The function handles division between the Vector2D other and a numeric value or another Vector2D other.
-
-            If n is a numeric value (int or float):
-                - If n is zero, the function returns a Vector2D other with zeros for both components if error_mode is "zero".
-                - If error_mode is "null", the function returns a Vector2D other with the original x or y component if available,
-                  otherwise, return NaN (Not a Number) for the component.
-
-            If n is a Vector2D other:
-                - If n's x or y component is zero, the function returns a Vector2D other with zeros for the corresponding component
-                  if error_mode is "zero".
-                - If error_mode is "null", the function returns a Vector2D other with the original x or y component if available,
-                  otherwise, return NaN (Not a Number) for the component.
-
-            If n is neither a numeric value nor a Vector2D other, the function raises an exception.
-        """
         if any(isinstance(n, cls) for cls in {int, float}):
             if n == 0:
                 return Vector2D(0 if error_mode == "zero" else (self.x if error_mode == "null" else _mt.nan), 0 if error_mode == "zero" else (self.y if error_mode == "null" else _mt.nan))
@@ -833,30 +313,13 @@ class Vector2D:
                 raise TypeError(f"The value {other} is not a num type: [{int|float}] nor an array type: [{list|tuple}]")
         return other
 
+try:
+    from e2D.Cmain import * #type: ignore
+except Exception as err:
+    raise Warning(f"Unable to load the C-version on Vector2D: \n\t{err}")
+
 class V2(Vector2D):
     def  __init__(self:"V2|Vector2D", x: int|float = 0, y: int|float = 0) -> None:
-        """
-        # Initialize a 2D vector (V2) with the specified x and y components.
-
-        ## Parameters:
-            x (int | float, optional): The x-component of the vector. Default is 0.
-            y (int | float, optional): The y-component of the vector. Default is 0.
-
-        ## Example:
-            vector1 = V2()        # Creates a V2 other with x=0 and y=0
-            vector2 = V2(3, -2.5) # Creates a V2 other with x=3 and y=-2.5
-
-        ## Explanation:
-            This class is an alias for the Vector2D class, with the benefit of using a shorter name (V2).
-
-            The constructor initializes a V2 other with the specified x and y components.
-
-            If no arguments are provided, the default values for x and y are both set to 0.
-
-            The x and y components can be integers or floating-point numbers.
-
-            Example usage is shown in the "Example" section above.
-        """
         super().__init__(x, y)
 
 V2inf = Vector2D(float('inf'), float('inf'))
@@ -1041,6 +504,12 @@ def angular_interpolation(starting_angle:int|float, final_angle:int|float, step:
     distances = (final_angle - starting_angle, final_angle - DOUBLE_PI - starting_angle, final_angle + DOUBLE_PI - starting_angle)
     return min(distances, key=abs) * step
 
+def bezier_cubic_interpolation(t:float, p0:Vector2D|V2, p1:Vector2D|V2) -> float:
+    return t*p0.y*3*(1 - t)**2 + p1.y*3*(1 - t) * t**2 + t**3
+
+def bezier_quadratic_interpolation(t:float, p0:Vector2D|V2) -> float:
+    return 2*(1-t)*t*p0.y+t**2
+
 def avg_position(*others:"Vector2D|V2") -> Vector2D|V2:
     """
     # Calculate the average position for a variable number of Vector2D others.

{e2D-1.4.0 → e2D-1.4.2}/e2D/plots.py

@@ -1,22 +1,93 @@
 from __future__ import annotations
 from .envs import *
 import numpy as np
-import ctypes
 
 class Function:
     def __init__(self) -> None:
         self.plot : Plot
         self.__layer_surface__ :pg.Surface= None #type: ignore
     
+    def __post_load_init__(self, plot:Plot) -> None:
+        self.plot = plot
+        self.__layer_surface__ = pg.Surface(self.plot.size(), pg.SRCALPHA, 32).convert_alpha()
+        self.update()
+        self.plot.functions.append(self)
+    
     def update(self) -> None: pass
     
-    def render(self) -> None: pass
+    def __render__(self) -> None: pass
     
     def draw(self) -> None:
         self.plot.canvas.blit(self.__layer_surface__, (0,0))
 
+class Object:
+    def __init__(self) -> None:
+        self.plot : Plot
+        self.__layer_surface__ :pg.Surface= None #type: ignore
+        self.__controller__ = None
+    
+    def __post_load_init__(self, plot:Plot, controller:Plot|Object) -> None:
+        self.plot = plot
+        self.__layer_surface__ = pg.Surface(self.plot.size(), pg.SRCALPHA, 32).convert_alpha()
+        self.__controller__ = controller
+        self.plot.objects.append(self)
+        if isinstance(self, Line):
+            self.point_a.__post_load_init__(self.plot, self)
+            self.point_b.__post_load_init__(self.plot, self)
+    
+    def update(self) -> None: pass
+    
+    def __render__(self) -> None: pass
+    
+    def draw(self) -> None:
+        self.plot.canvas.blit(self.__layer_surface__, (0,0))
+
+class Line(Object):
+    def __init__(self, point_a:V2|Vector2D|Point, point_b:V2|Vector2D|Point, color:list[float]|tuple[float,float,float]=(255,255,255), width:float=1) -> None:
+        super().__init__()
+        if isinstance(point_a, Point):
+            self.point_a = point_a
+        else:
+            self.point_a = Point(point_a)
+        if isinstance(point_b, Point):
+            self.point_b = point_b
+        else:
+            self.point_b = Point(point_b)
+        self.color = color
+        self.width = width
+    
+    def update(self) -> None:
+        self.__render__()
+
+    def __render__(self) -> None:
+        self.__layer_surface__.fill((0,0,0,0))
+        if self.point_a.__controller__ == self: self.point_a.update()
+        if self.point_b.__controller__ == self: self.point_b.update()
+        pg.draw.line(self.__layer_surface__, self.color, self.point_a.center(), self.point_b.center(), self.width)
+
+class Point(Object):
+    def __init__(self, position, label:str="", radius:float=1, color:list[float]|tuple[float,float,float]=(255,255,255)) -> None:
+        super().__init__()
+        self.position = position
+        self.radius = radius
+        self.color = color
+        self.label = label
+        self.rect :list[float]= [0, 0, 0, 0]
+        self.center = V2z.copy()
+
+    def update(self) -> None:
+        radius = self.radius * self.plot.size / (self.plot.bottom_right_plot_coord - self.plot.top_left_plot_coord) * self.plot.__y_axis_multiplier__
+        self.center = self.plot.__plot2real__(self.position)
+        position = self.center - radius * .5
+        self.rect = position() + radius()
+        self.__render__()
+
+    def __render__(self) -> None:
+        self.__layer_surface__.fill((0,0,0,0))
+        pg.draw.ellipse(self.__layer_surface__, self.color, self.rect)
+
 class MathFunction(Function):
-    def __init__(self, function, color:list[float]|tuple[float,float,float]=(255,255,255), domain:list[float]=[-np.inf, np.inf], codomain:list[float]=[-np.inf, np.inf]) -> None:
+    def __init__(self, function, 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:
         super().__init__()
         self.color = color
         self.function = function
@@ -29,8 +100,6 @@ class MathFunction(Function):
         # credits for the plotting idea:
         # https://www.youtube.com/watch?v=EvvWOaLgKVU
         # mattbatwings (https://www.youtube.com/@mattbatwings)
-        
-        # real_domain = self.plot.__plot2real__()
         domain = [((domain - self.plot.top_left_plot_coord.x) * self.plot.size.x / (self.plot.bottom_right_plot_coord.x - self.plot.top_left_plot_coord.x)) for domain in self.domain]
         codomain = [((codomain - self.plot.top_left_plot_coord.y) * self.plot.size.y / (self.plot.bottom_right_plot_coord.y - self.plot.top_left_plot_coord.y)) for codomain in self.codomain]
         
@@ -48,12 +117,12 @@ class MathFunction(Function):
         if codomain != None: self.codomain = codomain
         if render:
             self.points = self.get_points()
-            self.render()
+            self.__render__()
     
     def get_derivative(self, delta:float=.01, color:None|list[float]|tuple[float,float,float]=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)
+        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:
+    def __render__(self) -> None:
         self.__layer_surface__.fill((0,0,0,0))
         offset = self.plot.dragging - self.plot.start_dragging if (self.plot.dragging != None) and (not self.plot.settings.get("use_real_time_rendering")) else V2z
         if any(x < 1 for x in self.plot.scale):
@@ -67,7 +136,47 @@ class MathFunction(Function):
                 if self.plot.dragging != None:
                     point = round(point + offset)()
                 self.__layer_surface__.set_at(point, self.color) #type: ignore
-    
+
+class TimeFunction(Function):
+    def __init__(self, function, t_range:list[float]=[0,0, 1.0], t_step:float=.01, color:list[float]|tuple[float,float,float]=(255,255,255)) -> None:
+        super().__init__()
+        self.color = color
+        self.function = function
+        self.t_range = t_range
+        self.t_step = t_step
+    def get_points(self) -> list:
+        signs_self = np.sign(self.function(*self.plot.meshgrid))
+        domain = [((domain - self.plot.top_left_plot_coord.x) * self.plot.size.x / (self.plot.bottom_right_plot_coord.x - self.plot.top_left_plot_coord.x)) for domain in self.domain]
+        codomain = [((codomain - self.plot.top_left_plot_coord.y) * self.plot.size.y / (self.plot.bottom_right_plot_coord.y - self.plot.top_left_plot_coord.y)) for codomain in self.codomain]
+        signs_sum = signs_self + np.roll(signs_self, axis=1, shift=1) + np.roll(signs_self, axis=0, shift=-1) + np.roll(signs_self, axis=(1,0), shift=(1,-1))
+        coords = np.column_stack(np.where(((-4 < signs_sum) & (signs_sum < 4))[:-1, 1:])[::-1]) / self.plot.scale()
+        return coords[
+            np.logical_and(
+                np.logical_and(coords[:, 0] >= domain[0], coords[:, 0] <= domain[1]),
+                np.logical_and(coords[:, 1] >= codomain[0], coords[:, 1] <= codomain[1]))] #type: ignore
+    def update(self, new_function=None, render=True, domain:list[float]|None=None, codomain:list[float]|None=None) -> None:
+        if new_function != None:
+            self.function = new_function
+        if domain != None: self.domain = domain
+        if codomain != None: self.codomain = codomain
+        if render:
+            self.points = self.get_points()
+            self.__render__()
+    def __render__(self) -> None:
+        self.__layer_surface__.fill((0,0,0,0))
+        offset = self.plot.dragging - self.plot.start_dragging if (self.plot.dragging != None) and (not self.plot.settings.get("use_real_time_rendering")) else V2z
+        if any(x < 1 for x in self.plot.scale):
+            # draw rects
+            for point in self.points:
+                pg.draw.rect(self.__layer_surface__, self.color, (point.tolist() + offset)() + self.plot.pixel_size()) #type: ignore
+        else:
+            # draw points
+            for point in self.points:
+                point = point.astype(int).tolist()
+                if self.plot.dragging != None:
+                    point = round(point + offset)()
+                self.__layer_surface__.set_at(point, self.color) #type: ignore
+
 class PointsFunction(Function):
     def __init__(self, points:list[V2|Vector2D]=[], points_color:list[float]|tuple[float,float,float]=(255,0,0), color:list[float]|tuple[float,float,float]=(255,255,255)) -> None:
         super().__init__()
@@ -80,9 +189,9 @@ class PointsFunction(Function):
         self.plot_points = [self.plot.__plot2real__(point)() for point in self.points if \
                         self.plot.top_left_x < point.x < self.plot.bottom_right_x and \
                         self.plot.bottom_right_y < point.y < self.plot.top_left_y]
-        self.render()
+        self.__render__()
 
-    def render(self) -> None:
+    def __render__(self) -> None:
         self.__layer_surface__.fill((0,0,0,0))
         if len(self.plot_points)>=2: pg.draw.lines(self.__layer_surface__, self.color, False, self.plot_points) #type: ignore
         # for point in self.points:
@@ -225,30 +334,25 @@ class Plot:
     __y_axis_multiplier__ = V2(1, -1)
     def __init__(self, rootEnv:"RootEnv", plot_position:V2|Vector2D, plot_size:V2|Vector2D, top_left_plot_coord:V2|Vector2D, bottom_right_plot_coord: V2|Vector2D, scale:V2|Vector2D=V2one) -> None:
         self.rootEnv = rootEnv
-
         self.top_left_plot_coord = top_left_plot_coord
         self.bottom_right_plot_coord = bottom_right_plot_coord
-
         self.position = plot_position
         self.size = plot_size
         self.scale = scale
-
         self.settings = __PlotSettings__(self)
         self.functions :list[Function]= []
-
+        self.objects :list[Object]= []
         self.canvas = pg.Surface(self.size(), pg.SRCALPHA, 32).convert_alpha()
         self.dragging = None
         self.start_dragging = V2z
         self.is_mouse_in_rect = False
         self.mouse_scalar = V2one.copy()
-
         self.plot_mouse_position = V2z.copy()
-
-        self.focus(V2(0,0), 10)
+        self.focus_using_corners(top_left_plot_coord, bottom_right_plot_coord)
 
     def set_borders_by_position_and_zoom(self) -> None:
-        self.top_left_plot_coord = self.current_offset - (.5**(.1*self.current_zoom)) * self.__y_axis_multiplier__
-        self.bottom_right_plot_coord = self.current_offset + (.5**(.1*self.current_zoom)) * self.__y_axis_multiplier__
+        self.top_left_plot_coord = self.current_offset - 2**(-.1*self.current_zoom) * self.__y_axis_multiplier__
+        self.bottom_right_plot_coord = self.current_offset + 2**(-.1*self.current_zoom) * self.__y_axis_multiplier__
         self.top_left_x, self.top_left_y = self.top_left_plot_coord
         self.bottom_right_x, self.bottom_right_y = self.bottom_right_plot_coord
 
@@ -263,13 +367,21 @@ class Plot:
                 self.pixel_size += V2one
 
     def load_function(self, function:Function) -> None:
-        function.plot = self
-        function.__layer_surface__ = pg.Surface(self.size(), pg.SRCALPHA, 32).convert_alpha()
-        function.update()
-        self.functions.append(function)
-    
+        function.__post_load_init__(self)
     def add_function(self, function:Function) -> None:
         self.load_function(function)
+    
+    def load_object(self, obj:Object) -> None:
+        obj.__post_load_init__(self, self)
+    def add_object(self, function:Object) -> None:
+        self.load_object(function)
+    
+    def add(self, *data:Object|Function) -> None:
+        for d in data:
+            if isinstance(d, Object):
+                self.load_object(d)
+            elif isinstance(d, Function):
+                self.load_function(d)
 
     def __plot2real__(self, plot_position:V2|Vector2D) -> V2|Vector2D:
         return (plot_position + self.top_left_plot_coord * -1) * self.size / (self.bottom_right_plot_coord - self.top_left_plot_coord)
@@ -295,6 +407,8 @@ class Plot:
 
         # draw functions
         for function in self.functions: function.draw()
+        # draw objects
+        for obj in self.objects: obj.draw()
 
         # draw rect, pointer and corner coords
         if self.settings.get("draw_rect"):
@@ -378,18 +492,28 @@ class Plot:
                 self.update_grid()
                 self.render()
         
+    def get_humanoid_zoom(self) -> None:
+        return 2 ** (-.1*self.current_zoom)
+        
     def focus(self, center:V2|Vector2D|None=None, zoom:float|Vector2D|V2|None=None) -> None:
         if center != None:
             self.current_offset = center.copy()
         if zoom != None:
             if any(isinstance(zoom, cls) for cls in {Vector2D, V2}):
-                self.current_zoom = 0-V2(np.log2(zoom.x), np.log2(zoom.y)) * 10
+                self.current_zoom = V2(np.log2(zoom.x), np.log2(zoom.y)) * -10
             else:
                 self.current_zoom = V2one * -np.log2(zoom)*10
         
         self.update_grid(True)
         for function in self.functions: function.update()
+        for obj in self.objects: obj.update()
         self.render()
+    
+    def focus_using_corners(self, top_left_plot_coord:V2|Vector2D|None=None, bottom_right_plot_coord: V2|Vector2D|None=None) -> None:
+        self.focus(
+            (top_left_plot_coord + bottom_right_plot_coord)/2,
+            (bottom_right_plot_coord - top_left_plot_coord)/2 * self.__y_axis_multiplier__
+            )   
 
     def draw(self) -> None:
         # fill canvas with bg color

{e2D-1.4.0 → e2D-1.4.2}/e2D/winrec.py

@@ -1,7 +1,7 @@
 from e2D.envs import *
 import pygame as pg
-import cv2
 import numpy as np
+import cv2
 
 class WinRec:
     def __init__(self, rootEnv:RootEnv, fps:int=30, path:str='output.mp4') -> None:
@@ -17,9 +17,14 @@ class WinRec:
     def update(self) -> None:
         frame = cv2.cvtColor(np.swapaxes(pg.surfarray.array3d(self.rootEnv.screen), 0, 1), cv2.COLOR_RGB2BGR)
         self.video_writer.write(frame)
+    
+    def get_rec_seconds(self) -> float:
+        return self.rootEnv.current_frame/self.fps
 
-    def draw(self) -> None:
-        self.rootEnv.print(f"[cfps:{self.rootEnv.current_frame} || realtime:{round(self.rootEnv.current_frame/self.fps,2)} || apptime:{round(self.rootEnv.get_time_from_start(),2)}]", self.rootEnv.screen_size, fixed_sides=TEXT_FIXED_SIDES_BOTTOM_RIGHT)
+    def draw(self, draw_on_screen=False) -> None:
+        text = f"[cfps:{self.rootEnv.current_frame} || realtime:{round(self.get_rec_seconds(),2)} || apptime:{round(self.rootEnv.get_time_from_start(),2)}]"
+        pg.display.set_caption(text)
+        if draw_on_screen: self.rootEnv.print(text, self.rootEnv.screen_size, fixed_sides=TEXT_FIXED_SIDES_BOTTOM_RIGHT)
     
     def quit(self) -> None:
         self.video_writer.release()

{e2D-1.4.0 → e2D-1.4.2}/e2D.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: e2D
-Version: 1.4.0
+Version: 1.4.2
 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.0 → e2D-1.4.2}/setup.cfg

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