e2D 1.3.2__tar.gz → 1.3.4__tar.gz

{e2D-1.3.2 → e2D-1.3.4}/PKG-INFO

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

@@ -315,11 +315,11 @@ class Vector2D:
             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 isinstance(start, Vector2D|V2):
+        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)
             else: raise Exception(f"\nArg start must be in [Vector2D, int, float, tuple, list] not a [{type(start)}]\n")
-        if not isinstance(end, Vector2D|V2):
+        if not any(isinstance(end, cls) for cls in {Vector2D, V2}):
             if type(end) in int|float: end = Vector2D(end, end) #type: ignore
             elif type(end) == None: end = Vector2D(1,1)
             else: raise Exception(f"\nArg end must be in [Vector2D, int, float, tuple, list] not a [{type(end)}]\n")
@@ -704,12 +704,12 @@ class Vector2D:
 
             If n is neither a numeric value nor a Vector2D other, the function raises an exception.
         """
-        if isinstance(n, int|float):
+        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))
             else:
                 return self / n
-        elif isinstance(n, Vector2D|V2):
+        elif any(isinstance(n, cls) for cls in {Vector2D, V2}):
             return Vector2D((0 if error_mode == "zero" else (self.x if error_mode == "null" else _mt.nan)) if n.x == 0 else self.x / n.x, (0 if error_mode == "zero" else (self.y if error_mode == "null" else _mt.nan)) if n.y == 0 else self.y / n.y)
         else:
             raise Exception(f"\nArg n must be in [Vector2D, int, float, tuple, list] not a [{type(n)}]\n")
@@ -832,7 +832,7 @@ class Vector2D:
 
     # comparasion
     def __eq__(self, other) -> bool:
-        if not isinstance(other, Vector2D|V2|list|tuple):
+        if not any(isinstance(other, cls) for cls in {Vector2D, V2, list, tuple}):
             return False
         other = self.__normalize__(other)
         return self.x == other.x and self.y == other.y
@@ -868,9 +868,9 @@ class Vector2D:
     
     def __normalize__(self:"V2|Vector2D", other) -> "Vector2D|V2":
         if not isinstance(other, Vector2D):
-            if isinstance(other, int|float):
+            if any(isinstance(other, cls) for cls in {int, float}):
                 return Vector2D(other, other)
-            elif isinstance(other, list|tuple):
+            elif any(isinstance(other, cls) for cls in {list, tuple}):
                 return Vector2D(*other[:2])
             else:
                 raise TypeError(f"The value {other} is not a num type: [{int|float}] nor an array type: [{list|tuple}]")

{e2D-1.3.2 → e2D-1.3.4}/e2D/envs.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from .utils import *
 import pygame as pg
 
@@ -65,7 +66,7 @@ class RootEnv:
         text_box = font.render(text, True, color)
         size = V2(*text_box.get_size()) + margin * 2
         position = position - size * self.__fixed_sides_multiplier[fixed_sides] + margin
-        if not isinstance(border_radius, tuple|list): border_radius = [border_radius]*4
+        if not any(isinstance(border_radius, cls) for cls in {tuple, list}): border_radius = [border_radius]*4
         surface = (self.screen if personalized_surface == None else personalized_surface)
         if bg_color != None:
             pg.draw.rect(surface, bg_color, (position - margin)() + size(), 0, -1, *border_radius)

e2D-1.3.4/e2D/plots.py

@@ -0,0 +1,272 @@
+from __future__ import annotations
+from .envs import *
+import numpy as np
+
+def no_error_complex_function(function, args) -> V2|Vector2D:
+    res :complex= function(args)
+    return V2(res.real, res.imag)
+
+sign = lambda value: -1 if value < 0 else (1 if value > 0 else 0)
+
+class Function:
+    def __init__(self, function, color) -> None:
+        self.plot : Plot
+        self.color = color
+        self.function = function
+    
+    def update_points(self) -> None:
+        self.update_function(self.function)
+
+    def get_points(self) -> list:
+        signs_self = np.sign(self.function(*self.plot.meshgrid))
+        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))
+        return np.column_stack(np.where(((-4 < signs_sum) & (signs_sum < 4))[:-1, 1:])[::-1]) / self.plot.scale()
+    
+    def update_function(self, new_function) -> None:
+        self.function = new_function
+        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 None
+        if any(x < 1 for x in self.plot.scale):
+            for point in self.points:
+                # radius = max(min(self.plot.pixel_size)*.5, 1)
+                # pg.draw.circle(self.plot.canvas, self.color, (point + self.plot.pixel_size*.5)(), radius)
+                pg.draw.rect(self.__layer_surface__, self.color, (point.tolist() + (offset if offset != None else V2z))() + self.plot.pixel_size()) #type: ignore
+        else:
+            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)
+    
+    def draw(self) -> None:
+        self.plot.canvas.blit(self.__layer_surface__, (0,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:
+#         self.auto_connect_treshold = auto_connect_treshold
+#         self.plot = plot
+#         self.starting_t = starting_t
+#         self.ending_t = ending_t
+#         self.color = color
+#         self.step = step
+#         self.points_color = points_color
+#         self.points_radius = points_radius
+#         self.update_function(function)
+    
+#     def update_points(self) -> None:
+#         self.update_function(self.function)
+    
+#     def update_function(self, new_function) -> None:
+#         self.function = new_function
+#         self.points :list[V2|Vector2D]= [point for t in range(int(self.starting_t / self.step), int(self.ending_t / self.step)) if (self.plot.bottom_right_y < (point:=no_error_complex_function(new_function, t * self.step)).y < self.plot.top_left_y) and (self.plot.top_left_x < point.x < self.plot.bottom_right_x)]
+#         self.full_auto_connect = not any(point.distance_to(self.points[i]) > self.auto_connect_treshold for i,point in enumerate(self.points[1:]))
+
+#     def draw(self) -> None:
+#         if self.points_radius:
+#             for point in self.points:
+#                 pg.draw.circle(self.plot.canvas, self.color if self.points_color == None else self.points_color, self.plot.__plot2real__(point)(), self.points_radius)
+
+#         if len(self.points) < 2: return
+#         if self.full_auto_connect:
+#             pg.draw.lines(self.plot.canvas, self.color, False, [self.plot.__plot2real__(point)() for point in self.points])
+#         else:
+#             real_points = [self.plot.__plot2real__(point)() for point in self.points]
+#             for i,(point, real_point) in enumerate(zip(self.points[1:], real_points[1:])):
+#                 if point.distance_to(self.points[i]) < self.auto_connect_treshold:
+#                     pg.draw.line(self.plot.canvas, self.color, real_points[i], real_point) #type: ignore
+
+class __PlotSettings__:
+    def __init__(self, plot:Plot) -> None:
+        self.plot = plot
+        self.settings :dict[str: bool|V2|Vector2D|int|float]= {
+            "use_real_time_rendering" : True,
+            "show_corners_coords" : True,
+
+            "use_inter_pixel_correction" : True,
+
+            "show_zoom_info": True,
+            "top_left_info_position" : self.plot.position + V2(20, 100),
+            "info_spacing" : V2(0, 32),
+            "info_precision" : 2,
+
+            "distance_to_axis_for_scalar_zoom" : 10,
+
+            "bg_color" : (25, 25, 25),
+            "axes_default_color" : (100, 100, 100),
+            "x_axis_color" : None,
+            "y_axis_color" : None,
+
+            "axes_default_width" : 5,
+            "x_axis_width" : None,
+            "y_axis_width" : None,
+
+            "show_cursor_coords" : False,
+        }
+
+    def print_current_settings(self) -> None:
+        longest_key = max(map(len, self.settings))
+        longest_type = max(map(lambda setting: len(str(type(setting)).split("'")[1]), self.settings.values()))
+        for setting in self.settings:
+            print(f"{setting}{' '*(longest_key-len(setting))} :{str(type(self.settings[setting])).split("'")[1]}{' '*(longest_type-len(str(type(self.settings[setting])).split("'")[1]))}=\t{self.settings[setting]}")
+    
+    def set(self, key:str, new_value) -> 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, keys:list[str], new_values:list) -> None:
+        for key, new_value in zip(keys, new_values):
+            self.set(key, new_value)
+    
+    def get(self, key:str) -> bool|V2|Vector2D|int|float:
+        return self.settings[key]
+
+    def multiple_set(self, keys:list[str]) -> list[bool|V2|Vector2D|int|float]:
+        return [self.get(key) for key in keys]
+
+class Plot:
+    __top_left_multiplier__ = V2(1, -1)
+    __bottop_right_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.current_zoom = V2one * -np.log2(10)*10
+        self.current_offset = V2(0,0)
+        self.update_grid(True)
+
+        self.functions :list[Function]= []
+
+        self.canvas = pg.Surface(self.size())
+        self.dragging = None
+        self.start_dragging = V2z
+        self.is_mouse_in_rect = False
+
+    def set_borders_by_position_and_zoom(self) -> None:
+        self.top_left_plot_coord = self.current_offset - (.5**(.1*self.current_zoom)) * self.__top_left_multiplier__
+        self.bottom_right_plot_coord = self.current_offset + (.5**(.1*self.current_zoom)) * self.__bottop_right_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
+
+    def update_grid(self, update_step_grid=False) -> None:
+        self.set_borders_by_position_and_zoom()
+        if update_step_grid:
+            self.step = (self.bottom_right_plot_coord - self.top_left_plot_coord) / self.size / self.scale
+            X, Y = np.arange(self.top_left_plot_coord.x, self.bottom_right_plot_coord.x, self.step.x), np.arange(self.top_left_plot_coord.y, self.bottom_right_plot_coord.y, self.step.y)
+            self.meshgrid = np.meshgrid(X, Y)
+            self.pixel_size = abs(self.size / (self.bottom_right_plot_coord - self.top_left_plot_coord) * (self.step * -1))
+            if self.settings.get("use_inter_pixel_correction"):
+                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_function(function.function)
+        self.functions.append(function)
+
+    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)
+
+    def __real2plot__(self, real_position:V2|Vector2D) -> V2|Vector2D:
+        return (real_position - self.position) * (self.bottom_right_plot_coord - self.top_left_plot_coord) / self.size + self.top_left_plot_coord
+
+    def render(self) -> None:
+        self.canvas.fill(self.settings.get("bg_color"))
+        if self.top_left_x < 0 < self.bottom_right_x:
+            pg.draw.line(self.canvas,
+                         self.settings.get("axes_default_color") if (x_color:=self.settings.get("x_axis_color"))==None else x_color,
+                         self.__plot2real__(V2(0, self.top_left_y))(),
+                         self.__plot2real__(V2(0, self.bottom_right_y))(),
+                         self.settings.get("axes_default_width") if (x_width:=self.settings.get("x_axis_width"))==None else x_width)
+        if self.bottom_right_y < 0 < self.top_left_y:
+            pg.draw.line(self.canvas,
+                         self.settings.get("axes_default_color") if (y_color:=self.settings.get("y_axis_color"))==None else y_color,
+                         self.__plot2real__(V2(self.top_left_x, 0))(),
+                         self.__plot2real__(V2(self.bottom_right_x, 0))(),
+                         self.settings.get("axes_default_width") if (y_width:=self.settings.get("y_axis_width"))==None else y_width)
+
+        for function in self.functions: function.draw()
+
+        pg.draw.rect(self.canvas, (255,255,255), V2z() + self.size(), 5) #type: ignore
+
+        center = self.size * .5
+        aimer_radius = 15
+        pg.draw.line(self.canvas, (100,100,100), (center + aimer_radius)(), (center - aimer_radius)(), 1)
+        pg.draw.line(self.canvas, (100,100,100), (center + self.__top_left_multiplier__ * aimer_radius)(), (center - self.__top_left_multiplier__ * aimer_radius)(), 1)
+        pg.draw.circle(self.canvas, (100,100,100), (self.size * .5)(), 15, 1)
+
+        if self.settings.get("show_corners_coords"):
+            self.rootEnv.print(str(self.top_left_plot_coord.__round__(.1)), V2z.copy(), bg_color=(0,0,0), border_color=(255,255,255), border_width=2, border_radius=15, margin=V2(10,10), personalized_surface=self.canvas)
+            self.rootEnv.print(str(V2(self.top_left_plot_coord.x, self.bottom_right_plot_coord.y).__round__(.1)), self.size * V2(0, 1), fixed_sides=TEXT_FIXED_SIDES_BOTTOM_LEFT, bg_color=(0,0,0), border_color=(255,255,255), border_width=2, border_radius=15, margin=V2(10,10), personalized_surface=self.canvas)
+            self.rootEnv.print(str(self.bottom_right_plot_coord.__round__(.1)), self.size.copy(), fixed_sides=TEXT_FIXED_SIDES_BOTTOM_RIGHT, bg_color=(0,0,0), border_color=(255,255,255), border_width=2, border_radius=15, margin=V2(10,10), personalized_surface=self.canvas)
+            self.rootEnv.print(str(V2(self.bottom_right_plot_coord.x, self.top_left_plot_coord.y).__round__(.1)), self.size * V2(1, 0), fixed_sides=TEXT_FIXED_SIDES_TOP_RIGHT, bg_color=(0,0,0), border_color=(255,255,255), border_width=2, border_radius=15, margin=V2(10,10), personalized_surface=self.canvas)
+    
+    def update(self) -> None:
+        self.plot_mouse_position = self.__real2plot__(self.rootEnv.mouse.position)
+        self.plot_center_real_position = self.__plot2real__(V2z) + self.position
+
+        self.is_mouse_in_rect = self.position.x < self.rootEnv.mouse.position.x < self.position.x + self.size.x and \
+                                self.position.y < self.rootEnv.mouse.position.y < self.position.y + self.size.y
+
+        if self.rootEnv.mouse.just_released[0] and self.dragging != None:
+            self.dragging = None
+            self.update_grid(True)
+            for function in self.functions:
+                function.update_points()
+            self.render()
+        
+
+        if self.is_mouse_in_rect:
+            for event in self.rootEnv.events:
+                if event.type == pg.MOUSEWHEEL:
+                    
+                    range_n = self.settings.get("distance_to_axis_for_scalar_zoom")
+                    scalar = V2(0 if abs(self.plot_center_real_position.x - self.rootEnv.mouse.position.x) < range_n else 1, 0 if abs(self.plot_center_real_position.y - self.rootEnv.mouse.position.y) < range_n else 1)
+                    self.current_zoom += event.y * scalar
+
+                    self.update_grid(True)
+                    for function in self.functions:
+                        function.update_points()
+                    self.render()
+            
+            if self.rootEnv.mouse.just_pressed[0] and self.dragging == None:
+                self.dragging = self.rootEnv.mouse.position.copy()
+                self.start_dragging = self.dragging.copy()
+            
+        if self.dragging:
+            offset = (self.dragging - self.rootEnv.mouse.position)* V2(1, -1) * (abs(self.bottom_right_plot_coord - self.top_left_plot_coord) / self.size)
+            self.dragging = self.rootEnv.mouse.position.copy()
+            self.current_offset += offset
+
+            if self.settings.get("use_real_time_rendering"):
+                self.update_grid(True)
+                for function in self.functions: function.update_points()
+            else:
+                self.update_grid()
+            self.render()
+
+    def draw(self) -> None:
+        self.rootEnv.screen.blit(self.canvas, self.position())
+        if self.is_mouse_in_rect and self.settings.get("show_cursor_coords"):
+            self.rootEnv.print(str(round(self.plot_mouse_position, .1)), self.rootEnv.mouse.position, fixed_sides=TEXT_FIXED_SIDES_BOTTOM_MIDDLE)
+
+        data = [
+            [f"ZOOM:", TEXT_FIXED_SIDES_TOP_LEFT, self.settings.get("show_zoom_info")],
+            [f"  x: {self.current_zoom.x:.{self.settings.get("info_precision")}f};", TEXT_FIXED_SIDES_TOP_LEFT, self.settings.get("show_zoom_info")],
+            [f"  y: {self.current_zoom.y:.{self.settings.get("info_precision")}f};", TEXT_FIXED_SIDES_TOP_LEFT, self.settings.get("show_zoom_info")],
+        ]
+
+        for i, (d, fixed_side, show) in enumerate(data):
+            if show:
+                self.rootEnv.print(d, self.settings.get("top_left_info_position") + self.settings.get("info_spacing") * i, fixed_sides=fixed_side)

{e2D-1.3.2 → e2D-1.3.4}/e2D/utils.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import pygame as pg
 from e2D import *
 

{e2D-1.3.2 → e2D-1.3.4}/e2D.egg-info/PKG-INFO

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

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

e2D-1.3.2/e2D/plots.py

@@ -1,159 +0,0 @@
-from .envs import *
-import numpy as np
-import pickle as pk
-
-def no_error_complex_function(function, args) -> V2|Vector2D:
-    res :complex= function(args)
-    return V2(res.real, res.imag)
-
-sign = lambda value: -1 if value < 0 else (1 if value > 0 else 0)
-
-class Function:
-    def __init__(self, function, plot:"Plot", color) -> None:
-        self.plot = plot
-        self.color = color
-        self.update_function(function)
-    
-    def update_points(self) -> None:
-        self.update_function(self.function)
-
-    def get_points(self) -> list:
-        signs_self = np.sign(self.function(*self.plot.meshgrid))
-        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))
-        return np.column_stack(np.where(((-4 < signs_sum) & (signs_sum < 4))[:-1, 1:])[::-1]) / self.plot.scale()
-    
-    def update_function(self, new_function) -> None:
-        self.function = new_function
-        self.points = self.get_points()
-    
-    def draw(self) -> None:
-        # pg.draw.aalines(self.plot.canvas, self.color, False, self.points)
-        for point in self.points:
-            self.plot.canvas.set_at(list(map(int, point)), self.color)
-
-# 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:
-#         self.auto_connect_treshold = auto_connect_treshold
-#         self.plot = plot
-#         self.starting_t = starting_t
-#         self.ending_t = ending_t
-#         self.color = color
-#         self.step = step
-#         self.points_color = points_color
-#         self.points_radius = points_radius
-#         self.update_function(function)
-    
-#     def update_points(self) -> None:
-#         self.update_function(self.function)
-    
-#     def update_function(self, new_function) -> None:
-#         self.function = new_function
-#         self.points :list[V2|Vector2D]= [point for t in range(int(self.starting_t / self.step), int(self.ending_t / self.step)) if (self.plot.bottom_right_y < (point:=no_error_complex_function(new_function, t * self.step)).y < self.plot.top_left_y) and (self.plot.top_left_x < point.x < self.plot.bottom_right_x)]
-#         self.full_auto_connect = not any(point.distance_to(self.points[i]) > self.auto_connect_treshold for i,point in enumerate(self.points[1:]))
-
-#     def draw(self) -> None:
-#         if self.points_radius:
-#             for point in self.points:
-#                 pg.draw.circle(self.plot.canvas, self.color if self.points_color == None else self.points_color, self.plot.__plot2real__(point)(), self.points_radius)
-
-#         if len(self.points) < 2: return
-#         if self.full_auto_connect:
-#             pg.draw.lines(self.plot.canvas, self.color, False, [self.plot.__plot2real__(point)() for point in self.points])
-#         else:
-#             real_points = [self.plot.__plot2real__(point)() for point in self.points]
-#             for i,(point, real_point) in enumerate(zip(self.points[1:], real_points[1:])):
-#                 if point.distance_to(self.points[i]) < self.auto_connect_treshold:
-#                     pg.draw.line(self.plot.canvas, self.color, real_points[i], real_point) #type: ignore
-
-class Plot:
-    __top_left_multiplier__ = V2(1, -1)
-    __bottop_right_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.current_zoom = V2one * -np.log2(10)*10
-        self.current_offset = V2(0,0)
-        self.update_grid(True)
-
-        self.functions :list[Function]= []
-
-        self.canvas = pg.Surface(self.size())
-        self.dragging = None
-        self.is_mouse_in_rect = False
-
-    def set_borders_by_position_and_zoom(self) -> None:
-        self.top_left_plot_coord = self.current_offset - (.5**(.1*self.current_zoom)) * self.__top_left_multiplier__
-        self.bottom_right_plot_coord = self.current_offset + (.5**(.1*self.current_zoom)) * self.__bottop_right_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
-
-    def update_grid(self, update_step_grid=False) -> None:
-        self.set_borders_by_position_and_zoom()
-        if update_step_grid:
-            self.step = (self.bottom_right_plot_coord - self.top_left_plot_coord) / self.size / self.scale
-            X, Y = np.arange(self.top_left_plot_coord.x, self.bottom_right_plot_coord.x, self.step.x), np.arange(self.top_left_plot_coord.y, self.bottom_right_plot_coord.y, self.step.y)
-            self.meshgrid = np.meshgrid(X, Y)
-
-    def load_function(self, function:Function) -> None:
-        self.functions.append(function)
-
-    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)
-
-    def __real2plot__(self, real_position:V2|Vector2D) -> V2|Vector2D:
-        return (real_position - self.position) * (self.bottom_right_plot_coord - self.top_left_plot_coord) / self.size + self.top_left_plot_coord
-
-    def render(self) -> None:
-        self.canvas.fill((0,0,0))
-        if self.bottom_right_y < 0 < self.top_left_y: pg.draw.line(self.canvas, (100,100,100), self.__plot2real__(V2(self.top_left_x, 0))(), self.__plot2real__(V2(self.bottom_right_x, 0))())
-        if self.top_left_x < 0 < self.bottom_right_x: pg.draw.line(self.canvas, (100,100,100), self.__plot2real__(V2(0, self.top_left_y))(), self.__plot2real__(V2(0, self.bottom_right_y))())
-        
-        for function in self.functions: function.draw()
-
-        pg.draw.rect(self.canvas, (255,255,255), V2z() + self.size(), 5) #type: ignore
-        self.rootEnv.print(str(self.top_left_plot_coord.__round__(.1)), V2z.copy(), bg_color=(0,0,0), border_color=(255,255,255), border_width=2, border_radius=15, margin=V2(10,10), personalized_surface=self.canvas)
-        self.rootEnv.print(str(V2(self.top_left_plot_coord.x, self.bottom_right_plot_coord.y).__round__(.1)), self.size * V2(0, 1), fixed_sides=TEXT_FIXED_SIDES_BOTTOM_LEFT, bg_color=(0,0,0), border_color=(255,255,255), border_width=2, border_radius=15, margin=V2(10,10), personalized_surface=self.canvas)
-        self.rootEnv.print(str(self.bottom_right_plot_coord.__round__(.1)), self.size.copy(), fixed_sides=TEXT_FIXED_SIDES_BOTTOM_RIGHT, bg_color=(0,0,0), border_color=(255,255,255), border_width=2, border_radius=15, margin=V2(10,10), personalized_surface=self.canvas)
-        self.rootEnv.print(str(V2(self.bottom_right_plot_coord.x, self.top_left_plot_coord.y).__round__(.1)), self.size * V2(1, 0), fixed_sides=TEXT_FIXED_SIDES_TOP_RIGHT, bg_color=(0,0,0), border_color=(255,255,255), border_width=2, border_radius=15, margin=V2(10,10), personalized_surface=self.canvas)
-    
-    def update(self) -> None:
-        self.is_mouse_in_rect = self.position.x < self.rootEnv.mouse.position.x < self.position.x + self.size.x and \
-                                self.position.y < self.rootEnv.mouse.position.y < self.position.y + self.size.y
-
-        if self.rootEnv.mouse.just_released[0] and self.dragging != None:
-            self.dragging = None
-            self.update_grid(True)
-            for function in self.functions:
-                function.update_points()
-            self.render()
-
-        if self.is_mouse_in_rect:
-            for event in self.rootEnv.events:
-                if event.type == pg.MOUSEWHEEL:
-                    self.current_zoom += event.y
-                    self.update_grid(True)
-                    for function in self.functions:
-                        function.update_points()
-                    self.render()
-            
-            if self.rootEnv.mouse.just_pressed[0] and self.dragging == None:
-                self.dragging = self.rootEnv.mouse.position.copy()
-            
-        if self.dragging:
-            offset = (self.dragging - self.rootEnv.mouse.position)* V2(1, -1) * (abs(self.bottom_right_plot_coord - self.top_left_plot_coord) / self.size)
-            self.dragging = self.rootEnv.mouse.position.copy()
-            self.current_offset += offset
-            self.update_grid()
-            self.render()
-
-    def draw(self) -> None:
-        self.rootEnv.screen.blit(self.canvas, self.position())
-        if self.is_mouse_in_rect:
-            self.rootEnv.print(str(round(self.__real2plot__(self.rootEnv.mouse.position), .1)), self.rootEnv.mouse.position, fixed_sides=TEXT_FIXED_SIDES_BOTTOM_MIDDLE)