e2D 1.4.18__py3-none-any.whl → 1.4.20__py3-none-any.whl

e2D/__init__.py

@@ -10,6 +10,7 @@ PI_QUARTER = PI/4
 PI_DOUBLE = PI*2
 
 sign = lambda val: -1 if val < 0 else (1 if val > 0 else 0)
+clamp = lambda x, minn, maxx: x if x > minn and x < maxx else (minn if x < minn else maxx)
 
 class Vector2D:
     round_values_on_print = 2
@@ -17,7 +18,7 @@ class Vector2D:
         self.x = x
         self.y = y
 
-    def distance_to(self, other, rooted=True) -> float:
+    def distance_to(self, other, rooted=True) -> int|float:
         d = (self.x - other.x)**2 + (self.y - other.y)**2
         return d**(1/2) if rooted else d
 
@@ -42,6 +43,13 @@ class Vector2D:
     @property
     def sign(self) -> "Vector2D":
         return Vector2D(sign(self.x), sign(self.y))
+    
+    def clamp(self, min_val: Vector2D, max_val: Vector2D) -> "Vector2D":
+        return Vector2D(clamp(self.x, min_val.x, max_val.x), clamp(self.y, min_val.y, max_val.y))
+
+    def iclamp(self, min_val: Vector2D, max_val: Vector2D) -> None:
+        self.x = clamp(self.x, min_val.x, max_val.x)
+        self.y = clamp(self.y, min_val.y, max_val.y)
 
     @property
     def normalize(self) -> "Vector2D":
@@ -71,7 +79,7 @@ class Vector2D:
         return self.__round__(n)
 
     @classmethod
-    def randomize(cls, start, end) -> "Vector2D":
+    def randomize(cls, start, end, func=lambda val:val) -> "Vector2D":
         if not isinstance(start, Vector2D):
             if isinstance(start, (int, float)):
                 start = Vector2D(start, start)
@@ -82,7 +90,7 @@ class Vector2D:
                 end = Vector2D(end, end)
             else:
                 raise Exception(f"\nArg end must be in [Vector2D, int, float, tuple, list] not a [{type(end)}]\n")
-        return start + Vector2D(_rnd.random(), _rnd.random()) * (end - start)
+        return start + Vector2D(func(_rnd.random()), func(_rnd.random())) * (end - start)
     
     def dot_product(self, other) -> float:
         return self.x * other.x + self.y * other.y

e2D/__init__.pyi

@@ -12,6 +12,7 @@ PI_DOUBLE : float
 # 
 
 sign : Callable[[int|float], Literal[-1,0,1]]
+clamp: Callable[[int|float, int|float, int|float], int|float]
 
 class Vector2D:
     round_values_on_print : int|float
@@ -39,7 +40,7 @@ class Vector2D:
         self.x : int|float
         self.y : int|float
 
-    def distance_to(self:"Vector2D", other:"Vector2D", rooted:bool=True) -> float:
+    def distance_to(self:"Vector2D", other:"Vector2D", rooted:bool=True) -> int|float:
         """
         # Calculate the distance between the current Vector2D other and another other.
 
@@ -211,6 +212,54 @@ class Vector2D:
         """
         ...
     
+    def clamp(self, min_val: Vector2D, max_val: Vector2D) -> "Vector2D":
+        """
+        # Clamp the vector's components between the corresponding components of two other vectors.
+
+        ## Parameters:
+            min_val (Vector2D): The minimum vector for clamping.
+            max_val (Vector2D): The maximum vector for clamping.
+
+        ## Returns:
+            Vector2D: A new vector with its components clamped between the corresponding components of `min_val` and `max_val`.
+
+        ## Example:
+            v = Vector2D(5, 10)
+            min_val = Vector2D(0, 8)
+            max_val = Vector2D(6, 12)
+            clamped_v = v.clamp(min_val, max_val)
+            print(clamped_v)  # Output: (5, 10)
+
+        ## Explanation:
+            This method clamps the x and y components of the current vector between the corresponding x and y components
+            of the `min_val` and `max_val` vectors. The resulting vector is returned as a new Vector2D instance.
+        """
+        ...
+
+    def iclamp(self, min_val: Vector2D, max_val: Vector2D) -> None:
+        """
+        # Clamp the vector's components in place between the corresponding components of two other vectors.
+
+        ## Parameters:
+            min_val (Vector2D): The minimum vector for clamping.
+            max_val (Vector2D): The maximum vector for clamping.
+
+        ## Returns:
+            None
+
+        ## Example:
+            v = Vector2D(5, 10)
+            min_val = Vector2D(0, 8)
+            max_val = Vector2D(6, 12)
+            v.iclamp(min_val, max_val)
+            print(v)  # Output: (5, 10)
+
+        ## Explanation:
+            This method clamps the x and y components of the current vector in place between the corresponding x and y components
+            of the `min_val` and `max_val` vectors. The method modifies the current vector directly.
+        """
+        ...
+    
     @property
     def normalize(self:"Vector2D") -> "Vector2D":
         """
@@ -264,7 +313,7 @@ class Vector2D:
         ...
 
     @classmethod
-    def randomize(cls, start:"int|float|Vector2D", end:"int|float|Vector2D") -> "Vector2D":
+    def randomize(cls, start:"int|float|Vector2D", end:"int|float|Vector2D", func:Callable[[int|float], int|float]=lambda val:val) -> "Vector2D":
         """
         # Generate a random Vector2D point within the specified range.
 

e2D/colors.py

@@ -82,6 +82,12 @@ __conversion_table__ :dict[__LITERAL_COLOR_MODES__, dict[__LITERAL_COLOR_MODES__
         },
 }
 
+def pygamize_color(color: "__color_pygame__|Color") -> "__color_pygame__":
+    return color() if isinstance(color, Color) else color
+
+def unpygamize_color(color: "__color_pygame__|Color") -> "Color":
+    return Color(*color[:], mode=RGBA_COLOR_MODE) if isinstance(color, __color_pygame__) else color
+
 class Color:
     def __init__(self, *values, mode:__LITERAL_COLOR_MODES__=RGB_COLOR_MODE) -> None:
         self.__dict__ = dict(zip(mode, values))
@@ -179,7 +185,7 @@ class Color:
         return "Color(" + ", ".join(f"{k}:{v}" for k, v in self.items) + ")"
 
     def __call__(self) -> __color_pygame__:
-        return __color_pygame__(int(self.r), int(self.g), int(self.b))
+        return __color_pygame__(int(self.r), int(self.g), int(self.b)) if self.mode == RGB_COLOR_MODE else __color_pygame__(int(self.r), int(self.g), int(self.b), int(self.a))
     
     # fast operations     Vector2D.operation(both,x,y)
     def add(self, all3=.0, r=.0, g=.0, b=.0) -> "Color":
@@ -408,6 +414,8 @@ class Color:
         except:
             raise TypeError(f"The value {other} of type {type(other)} is not a num type: [{int|float}] nor an array type: [{list|tuple}]")
     
+    @classmethod
+    def transparent(cls) -> "Color": return Color(0,0,0,0, mode=RGBA_COLOR_MODE)
     @classmethod
     def white(cls) -> "Color": return Color(255,255,255)
     @classmethod
@@ -427,12 +435,14 @@ class Color:
         return Color(__randint__(0,255), __randint__(0,255), __randint__(0,255))
 
 
+TRANSPARENT_COLOR = Color.transparent()
 WHITE_COLOR = Color.white()
 BLACK_COLOR = Color.black()
 RED_COLOR = Color.red()
 GREEN_COLOR = Color.green()
 BLUE_COLOR = Color.blue()
 
+TRANSPARENT_COLOR_PYG = TRANSPARENT_COLOR() 
 WHITE_COLOR_PYG = WHITE_COLOR()
 BLACK_COLOR_PYG = BLACK_COLOR()
 RED_COLOR_PYG = RED_COLOR()

e2D/envs.py

@@ -59,12 +59,21 @@ class RootEnv:
         self.current_frame = 0
         self.show_fps = show_fps
         self.events :list[pg.event.Event]= []
-        self.background_color = BLACK_COLOR_PYG
+        
+        self.__background_color__ :Color= BLACK_COLOR_PYG
+        
         self.clear_screen_each_frame = clear_screen_each_frame
         self.utils :dict[int|str, Util]= {}
         self.selected_util :Util|None = None
         self.__quit_on_key_pressed__ = quit_on_key_pressed
 
+    @property
+    def background_color(self) -> Color:
+        return unpygamize_color(self.__background_color__)
+    @background_color.setter
+    def background_color(self, color: Color|pg.Color) -> None:
+        self.__background_color__ = pygamize_color(color)
+    
     @property
     def screen_size(self) -> Vector2D:
         return self.__screen_size__
@@ -76,7 +85,7 @@ class RootEnv:
 
     @property
     def delta(self) -> int:
-        return self.clock.get_time()
+        return self.clock.get_time() / 1000
 
     def get_teoric_max_fps(self) -> float:
         rawdelta = self.clock.get_rawtime()
@@ -96,6 +105,8 @@ class RootEnv:
         for util in utils:
             if util.surface == None: util.surface = self.screen
             util.rootEnv = self
+            util.id = self.__new_util_id__()
+            util.render()
             self.utils[util.id] = util
 
     def remove_utils(self, *utils:int|str|Util) -> None:
@@ -106,6 +117,18 @@ class RootEnv:
                 del self.utils[uid.id]
             else:
                 raise Exception(f"Unknown util type: {uid}")
+    
+    def __new_util_id__(self) -> int:
+        if not self.utils: return 0
+        else: return max(self.utils.keys()) + 1
+
+    def get_util(self, uid:int|str) -> Util|None:
+        if isinstance(uid, Util):
+            return self.utils.get(uid.id)
+        elif isinstance(uid, int) or isinstance(uid, str):
+            return self.utils.get(uid)
+        else:
+            raise Exception(f"Unknown util type: {uid}")
 
     @property
     def runtime_seconds(self) -> float:
@@ -115,24 +138,25 @@ class RootEnv:
         self.env = sub_env
 
     def clear(self) -> None:
-        self.screen.fill(self.background_color)
+        self.screen.fill(self.__background_color__)
 
     def clear_rect(self, position:Vector2D, size:Vector2D) -> None:
-        self.screen.fill(self.background_color, position() + size())
+        self.screen.fill(self.__background_color__, position() + size())
 
     def print(self, 
-            text : str, 
-            position : Vector2D, 
-            color : pg.Color = WHITE_COLOR_PYG,
-            pivot_position : __LITERAL_PIVOT_POSITIONS__ = "top_left",
-            font : pg.font.Font = FONT_ARIAL_32,
-            bg_color : None|pg.Color = None,
-            border_color : pg.Color = WHITE_COLOR_PYG,
-            border_width : float = 0.0,
-            border_radius : int|list[int]|tuple[int,int,int,int] = -1,
-            margin : Vector2D = Vector2D.zero(),
-            personalized_surface : pg.Surface|None = None
+              text : str, 
+              position : Vector2D, 
+              color : pg.color.Color = WHITE_COLOR_PYG,
+              pivot_position : __LITERAL_PIVOT_POSITIONS__ = "top_left",
+              font : pg.font.Font = FONT_ARIAL_32,
+              bg_color : None|pg.color.Color = None,
+              border_color : pg.color.Color = WHITE_COLOR_PYG,
+              border_width : float = 0.0,
+              border_radius : int|list[int]|tuple[int,int,int,int] = -1,
+              margin : Vector2D = Vector2D.zero(),
+              personalized_surface : pg.Surface|None = None
             ) -> None:
+
         text_box = font.render(text, True, color)
         size = Vector2D(*text_box.get_size()) + margin * 2
         pivotted_position = position - size * __PIVOT_POSITIONS_MULTIPLIER__[pivot_position] + margin

e2D/utils.py

@@ -96,78 +96,114 @@ class Keyboard:
 class Util:
     def __init__(self) -> None:
         self.rootEnv = None
-        self.surface : pg.Surface
+        self.surface : pg.Surface = pg.SurfaceType
         self.id : int|str
         self.is_hovered :bool= False
+        self.hidden :bool= False
+    def hide(self) -> None:
+        self.hidden = True
+    def show(self) -> None:
+        self.hidden = False
+    def render(self) -> None: pass
     def draw(self) -> None: pass
     def update(self) -> None: pass
 
 class InputCell(Util):
     def __init__(self,
-                id : int|str,
-                initial_value : str,
-                position : Vector2D,
-                size : Vector2D,
-                prefix : str|None = None,
-                text_color : Color = Color.white(),
-                bg_color : None|Color = None,
-                border_color : Color = Color.white(),
-                border_width : float = 0,
-                border_radius : int|list[int]|tuple[int,int,int,int] = -1,
-                margin : Vector2D = Vector2D.zero(),
-                pivot_position : __LITERAL_PIVOT_POSITIONS__ = "center_center",
-                font : pg.font.Font = FONT_ARIAL_32,
-                personalized_surface : pg.Surface|None = None,
-                on_enter_pressed : Callable[[str], Any] = lambda full_text: ...,
-                check_when_adding : Callable[[str], str] = lambda new_text: new_text
+                 initial_value : str,
+                 position : Vector2D,
+                 size : Vector2D,
+                 prefix : str|None = None,
+                 text_color : Color|pg.Color = Color.white(),
+                 bg_color : None|Color|pg.Color = None,
+                 border_color : Color|pg.Color = Color.white(),
+                 border_width : float = 0,
+                 border_radius : int|list[int]|tuple[int,int,int,int] = -1,
+                 margin : Vector2D = Vector2D.zero(),
+                 pivot_position : __LITERAL_PIVOT_POSITIONS__ = "center_center",
+                 font : pg.font.Font = FONT_ARIAL_32,
+                 personalized_surface : pg.Surface|None = None,
+                 on_enter_pressed : Callable[[str], Any] = lambda full_text: ...,
+                 check_when_adding : Callable[[str], str] = lambda new_text: new_text,
                 ) -> None:
         super().__init__()
+        
+        self.value = initial_value
 
-        self.id = id
-        self.on_enter_pressed = on_enter_pressed
-        self.check_when_adding = check_when_adding
-        self.prefix = prefix if prefix != None else ""
-    
-        self.text_color = text_color
-        self.font = font
-        self.surface = personalized_surface
-        self.bg_color = bg_color
         # size = Vector2D(*self.text_box.get_size()) + self.margin * 2
         self.size = size
         self.position = (position - size * __PIVOT_POSITIONS_MULTIPLIER__[pivot_position] + margin)
+
+        self.prefix = prefix if prefix != None else ""
+    
+        self.font = font
+        
         self.bg_rect = [0, 0] + size()
-        self.margin_rect = (margin * -1)() + size()
-        self.border_color = border_color
+        
         self.border_radius = [border_radius]*4 if not any(isinstance(border_radius, cls) for cls in {tuple, list}) else border_radius
         self.border_width = border_width
+        
+        self.margin_rect = (margin * -1)() + size()
 
-        self.value = initial_value
+        self.on_enter_pressed = on_enter_pressed
+        self.check_when_adding = check_when_adding
+        
         self.update_text()
 
+        self.surface = personalized_surface
         self.text_surface = pg.Surface(self.size(), pg.SRCALPHA, 32).convert_alpha()
+    
+        self.text_color = text_color
+        self.bg_color = bg_color
+        self.border_color = border_color
         
+    @property
+    def text_color(self) -> Color:
+        return unpygamize_color(self.__text_color__)
+    @text_color.setter
+    def text_color(self, new_color:Color|pg.Color) -> None:
+        self.__text_color__ = pygamize_color(new_color)
+    @property
+    def bg_color(self) -> Color|None:
+        return unpygamize_color(self.__bg_color__) if self.__bg_color__ else None
+    @bg_color.setter
+    def bg_color(self, new_color:Color|pg.Color|None) -> None:
+        self.__bg_color__ = pygamize_color(new_color) if new_color else None
+    @property
+    def border_color(self) -> Color:
+        return unpygamize_color(self.__border_color__)
+    @border_color.setter
+    def border_color(self, new_color:Color|pg.Color) -> None:
+        self.__border_color__ = pygamize_color(new_color)
+
     def draw(self) -> None:
-        self.text_surface.fill((0,0,0,0))
-        if self.bg_color != None:
-            pg.draw.rect(self.text_surface, self.bg_color(), self.bg_rect, 0, -1, *self.border_radius)
+        if self.hidden: return
+        self.text_surface.fill(TRANSPARENT_COLOR_PYG)
+        
+        if self.__bg_color__ is not None:
+            pg.draw.rect(self.text_surface, self.__bg_color__(), self.bg_rect, 0, -1, *self.border_radius)
         
         self.text_surface.blit(self.text_box, self.text_position())
         
         if self.rootEnv.selected_util != self:
             if self.border_width:
-                pg.draw.rect(self.text_surface, self.border_color(), self.margin_rect, self.border_width, -1, *self.border_radius)
+                pg.draw.rect(self.text_surface, self.__border_color__(), self.margin_rect, self.border_width, -1, *self.border_radius)
         else:
-            pg.draw.rect(self.text_surface, [127 + 127 * _mt.sin(self.rootEnv.runtime_seconds * 10)]*3, self.margin_rect, self.border_width if self.border_width else 10, -1, *self.border_radius)
+            k = 127.5 + 127.5 * _mt.sin(self.rootEnv.runtime_seconds * 10)
+            pg.draw.rect(self.text_surface, pg.Color(k, k, k), self.margin_rect, self.border_width if self.border_width else 10, -1, *self.border_radius)
 
         self.surface.blit(self.text_surface, self.position())
         
     def update(self) -> None:
+        if self.hidden: return
         self.is_hovered = self.position.x < self.rootEnv.mouse.position.x < self.position.x + self.size.x and\
                           self.position.y < self.rootEnv.mouse.position.y < self.position.y + self.size.y
+        
         if self.rootEnv.mouse.get_key(0, "just_pressed"):
             if self.is_hovered:
                 self.rootEnv.selected_util = self if self.rootEnv.selected_util != self else None
                 self.update_text()
+        
         if self.rootEnv.selected_util == self:
             for event in self.rootEnv.events:
                 if event.type == pg.TEXTINPUT:
@@ -183,9 +219,327 @@ class InputCell(Util):
             self.update_text()
 
     def update_text(self) -> None:
-        self.text_box = self.font.render(self.prefix + self.value, True, self.text_color())
+        self.text_box = self.font.render(self.prefix + self.value, True, self.__text_color__())
         if self.rootEnv != None and self.rootEnv.selected_util == self:
             # self.text_position = self.position + self.size * Vector2D(.85, .5) - Vector2D(*self.text_box.get_size()) * Vector2D(1, .5) - self.position
             self.text_position = self.position + self.size * .5 - Vector2D(*self.text_box.get_size()) * Vector2D(.5, .5) - self.position
         else:
             self.text_position = self.position + self.size * .5 - Vector2D(*self.text_box.get_size()) * Vector2D(.5, .5) - self.position
+
+class Slider(Util):
+    def __init__(self,
+                text : str,
+                position : Vector2D,
+                size : Vector2D,
+                min_value : float = 0,
+                max_value : float = 100,
+                step : float = 1,
+                color : Color|pg.Color = Color(200, 200, 200),
+                handleColour : Color|pg.Color = Color.white(),
+                initial_value : float = 0,
+                rounded : bool = True,
+                handleRadius : float = 10,
+                text_offset : V2 = V2(1.1, .5),
+                text_pivot : __LITERAL_PIVOT_POSITIONS__ = "center_center",
+                personalized_surface : pg.Surface|None = None,
+                ) -> None:
+        super().__init__()
+        
+        self.text = text
+        self.selected = False
+        self.min = min_value
+        self.max = max_value
+        self.step = step
+
+        self.position = position
+        self.size = size
+
+        self.value = clamp(initial_value, self.min, self.max)
+
+        self.radius = self.size.y // 2 if rounded else 0
+        self.text_offset = text_offset
+        self.text_pivot = text_pivot
+
+        self.handleRadius = handleRadius
+        self.surface = personalized_surface
+
+        self.hidden = False
+
+        self.color = color
+        self.handleColour = handleColour
+    
+    @property
+    def color(self) -> Color:
+        return unpygamize_color(self.__color__)
+    @color.setter
+    def color(self, new_color:Color|pg.Color) -> None:
+        self.__color__ = pygamize_color(new_color)
+    @property
+    def handleColour(self) -> Color:
+        return unpygamize_color(self.__handleColour__)
+    @handleColour.setter
+    def handleColour(self, new_color:Color|pg.Color) -> None:
+        self.__handleColour__ = pygamize_color(new_color)
+
+    def draw(self) -> None:
+        if self.hidden: return
+        pg.draw.rect(self.rootEnv.screen, self.__color__, self.position() + self.size())
+
+        if self.radius:
+            pg.draw.circle(self.rootEnv.screen, self.__color__, (self.position.x, self.position.y + self.size.y // 2), self.radius)
+            pg.draw.circle(self.rootEnv.screen, self.__color__, (self.position.x + self.size.x, self.position.y + self.size.y // 2), self.radius)
+
+        circle = V2(int(self.position.x + (self.value - self.min) / (self.max - self.min) * self.size.x), self.position.y + self.size.y // 2)
+
+        pg.draw.circle(self.rootEnv.screen, self.__color__, circle(), self.handleRadius * 1.25)
+        pg.draw.circle(self.rootEnv.screen, self.__handleColour__, circle(), self.handleRadius)
+        self.rootEnv.print(self.text.format(round(self.value, 2)), self.position + self.size * self.text_offset, pivot_position=self.text_pivot)
+    
+    def update(self) -> None:
+        if self.hidden: return
+        x,y = self.rootEnv.mouse.position
+
+        if self.rootEnv.mouse.get_key(0, "just_pressed") and self.__contains__(x, y):
+            self.rootEnv.selected_util = self
+        elif self.rootEnv.mouse.get_key(0, "just_released"):
+            self.rootEnv.selected_util = None
+        
+        if self.rootEnv.selected_util == self:
+            new_value = (x - self.position.x) / self.size.x * self.max + self.min
+            self.value = clamp(new_value, self.min, self.max)
+
+    def __contains__(self, x, y) -> bool:
+        handleX = self.position.x + (self.value - self.min) / (self.max - self.min) * self.size.x
+        handleY = self.position.y + self.size.y // 2
+        return (handleX - x) ** 2 + (handleY - y) ** 2 <= self.handleRadius ** 2
+
+    def setValue(self, value) -> None:
+        self.value = clamp(value, self.min, self.max)
+
+    def getValue(self) -> float:
+        return self.value
+
+class Button(Util):
+    def __init__(self,
+                text : str,
+                position : V2|Vector2D,
+                size : V2|Vector2D,
+                callback : Callable[[...], None]|Callable[[], None],
+                default_color : Color|pg.Color,
+                hovered_color : Color|pg.Color,
+                border_color : Color|pg.Color,
+                text_color : Color|pg.Color = WHITE_COLOR_PYG,
+                font : pg.font.Font = FONT_ARIAL_32,
+                border_radius : float = 10,
+                border_width : float = 10,
+                starting_hiddden : bool = False,
+                args : list = [],
+                activation_mode : __LITERAL_KEY_MODE_TYPES__ = "just_pressed",
+                pivot_position : __LITERAL_PIVOT_POSITIONS__ = "top_left",
+                personalized_surface : pg.Surface|None = None,
+            ) -> None:
+        super().__init__()
+        
+        self.text = text
+        self.font = font
+
+        self.callback = callback
+        
+        self.border_radius = border_radius
+        self.__size__ = size
+        self.__border_width__ = border_width
+        
+        self.update_position(position, pivot_position)
+
+        self.hidden = starting_hiddden
+        self.args = args
+
+        self.activation_mode = activation_mode
+    
+        self.hovered = False
+
+        self.text_color = text_color
+        self.default_color = default_color
+        self.border_color = border_color
+        self.hovered_color = hovered_color
+
+        self.surface = personalized_surface
+        self.update_surface()
+    
+    def update_position(self, new_position:V2, pivot_position:__LITERAL_PIVOT_POSITIONS__="top_left") -> None:
+        self.position = new_position - (self.__size__ + self.border_width * 2) * __PIVOT_POSITIONS_MULTIPLIER__[pivot_position]
+    
+    def update_surface(self, render=False) -> None:
+        self.buffer_surface = pg.Surface((self.__size__ + self.__border_width__ * 2)(), pg.SRCALPHA, 32).convert_alpha()
+        if render: self.render()
+
+    @property
+    def size(self) -> V2:
+        return self.__size__
+    @size.setter
+    def size(self, new_size:V2|Vector2D) -> None:
+        self.__size__ = new_size
+        self.update_surface(render=True)
+
+    @property
+    def border_width(self) -> float:
+        return self.__border_width__
+    @border_width.setter
+    def border_width(self, new_width:float) -> None:
+        self.__border_width__ = new_width
+        self.update_surface(render=True)
+    
+    @property
+    def text_color(self) -> Color:
+        return unpygamize_color(self.__text_color__)
+    @text_color.setter
+    def text_color(self, new_color:Color|pg.Color) -> None:
+        self.__text_color__ = pygamize_color(new_color)
+    @property
+    def default_color(self) -> Color:
+        return unpygamize_color(self.__default_color__)
+    @default_color.setter
+    def default_color(self, new_color:Color|pg.Color) -> None:
+        self.__default_color__ = pygamize_color(new_color)
+    @property
+    def border_color(self) -> Color:
+        return unpygamize_color(self.__border_color__)
+    @border_color.setter
+    def border_color(self, new_color:Color|pg.Color) -> None:
+        self.__border_color__ = pygamize_color(new_color)
+    @property
+    def hovered_color(self) -> Color:
+        return unpygamize_color(self.__hovered_color__)
+    @hovered_color.setter
+    def hovered_color(self, new_color:Color|pg.Color) -> None:
+        self.__hovered_color__ = pygamize_color(new_color)
+
+    def render(self) -> None:
+        print("rendering button")
+        self.buffer_surface.fill(TRANSPARENT_COLOR_PYG)
+
+        color = self.__hovered_color__ if self.hovered else self.__default_color__
+        pg.draw.rect(self.buffer_surface, self.__border_color__, V2.zero()() + (self.size + self.border_width * 2)(), border_radius=self.border_radius)
+        pg.draw.rect(self.buffer_surface, color, (V2.zero() + self.border_width)() + self.size(), border_radius=self.border_radius)
+
+        self.rootEnv.print(self.text, self.border_width + self.size * .5, color=self.__text_color__, font=self.font, pivot_position="center_center", personalized_surface=self.buffer_surface)
+
+    def draw(self) -> None:
+        if self.hidden: return
+        self.surface.blit(self.buffer_surface, (self.position)())
+
+    def update(self) -> None:
+        if self.hidden: return
+
+        old_overed = self.hovered
+        self.hovered = \
+            self.position.x < self.rootEnv.mouse.position.x < self.position.x + self.size.x and \
+            self.position.y < self.rootEnv.mouse.position.y < self.position.y + self.size.y
+        if self.hovered != old_overed:
+            self.render()
+        
+        if self.hovered and self.rootEnv.mouse.get_key(0, self.activation_mode):
+            self.callback(*self.args)
+            self.rootEnv.selected_util = self
+            self.render()
+        elif self.rootEnv.selected_util == self:
+            self.rootEnv.selected_util = None
+            self.render()
+
+class Label(Util):
+    def __init__(self,
+                text : str,
+                position : V2|Vector2D,
+                size : V2|Vector2D,
+                default_color : Color|pg.Color = TRANSPARENT_COLOR_PYG,
+                border_color : Color|pg.Color = WHITE_COLOR_PYG,
+                text_color : Color|pg.Color = WHITE_COLOR_PYG,
+                font : pg.font.Font = FONT_ARIAL_32,
+                border_radius : float = 10,
+                border_width : float = 10,
+                starting_hiddden : bool = False,
+                personalized_surface : pg.Surface|None = None,
+                pivot_position : __LITERAL_PIVOT_POSITIONS__ = "top_left",
+            ) -> None:
+        super().__init__()
+        
+        self.__text__ = text
+        self.font = font
+
+        self.border_radius = border_radius
+        self.__size__ = size
+        self.__border_width__ = border_width
+        
+        self.position = self.update_position(position, pivot_position)
+
+        self.hidden = starting_hiddden
+
+        self.text_color = text_color
+        self.default_color = default_color
+        self.border_color = border_color
+
+        self.surface = personalized_surface
+        self.update_surface()
+    
+    def update_position(self, new_position:V2, pivot_position:__LITERAL_PIVOT_POSITIONS__="top_left") -> None:
+        self.position = new_position - (self.__size__ + self.border_width * 2) * __PIVOT_POSITIONS_MULTIPLIER__[pivot_position]
+    
+    def update_surface(self, render=False) -> None:
+        self.buffer_surface = pg.Surface((self.__size__ + self.__border_width__ * 2)(), pg.SRCALPHA, 32).convert_alpha()
+        if render: self.render()
+
+    @property
+    def text(self) -> str:
+        return self.__text__
+    @text.setter
+    def text(self, new_text:str) -> None:
+        self.__text__ = new_text
+        self.render()
+
+    @property
+    def size(self) -> V2:
+        return self.__size__
+    @size.setter
+    def size(self, new_size:V2|Vector2D) -> None:
+        self.__size__ = new_size
+        self.update_surface(render=True)
+
+    @property
+    def border_width(self) -> float:
+        return self.__border_width__
+    @border_width.setter
+    def border_width(self, new_width:float) -> None:
+        self.__border_width__ = new_width
+        self.update_surface(render=True)
+    
+    @property
+    def text_color(self) -> Color:
+        return unpygamize_color(self.__text_color__)
+    @text_color.setter
+    def text_color(self, new_color:Color|pg.Color) -> None:
+        self.__text_color__ = pygamize_color(new_color)
+    @property
+    def default_color(self) -> Color:
+        return unpygamize_color(self.__default_color__)
+    @default_color.setter
+    def default_color(self, new_color:Color|pg.Color) -> None:
+        self.__default_color__ = pygamize_color(new_color)
+    @property
+    def border_color(self) -> Color:
+        return unpygamize_color(self.__border_color__)
+    @border_color.setter
+    def border_color(self, new_color:Color|pg.Color) -> None:
+        self.__border_color__ = pygamize_color(new_color)
+
+    def render(self) -> None:
+        print("rendering label")
+        self.buffer_surface.fill(TRANSPARENT_COLOR_PYG)
+
+        pg.draw.rect(self.buffer_surface, self.__border_color__, V2.zero()() + (self.size + self.border_width * 2)(), border_radius=self.border_radius)
+        pg.draw.rect(self.buffer_surface, self.__default_color__, (V2.zero() + self.border_width)() + self.size(), border_radius=self.border_radius)
+
+        self.rootEnv.print(self.text, self.border_width + self.size * .5, color=self.__text_color__, font=self.font, pivot_position="center_center", personalized_surface=self.buffer_surface)
+
+    def draw(self) -> None:
+        if self.hidden: return
+        self.surface.blit(self.buffer_surface, (self.position)())

{e2D-1.4.18.dist-info → e2d-1.4.20.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: e2D
-Version: 1.4.18
+Version: 1.4.20
 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
@@ -13,6 +13,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy
 Requires-Dist: pygame
+Dynamic: license-file
 
 # e2D
 ## A Python Game Development Library

e2d-1.4.20.dist-info/RECORD

@@ -0,0 +1,13 @@
+e2D/__init__.py,sha256=7UmgGI4WotqPLGXyGlNzddUdd5eK1VWqsb2BMAOA78g,22522
+e2D/__init__.pyi,sha256=ckPL2_iz5439-lD-wRLF7t54b_ndF4LT_A24_oyCCTU,45403
+e2D/colors.py,sha256=SwO52zowBs9l_VK1TjyT2GK1Npn5UAsHdCxz3lvaSKQ,18011
+e2D/def_colors.py,sha256=3sJq2L6qFZ3svn2qEWIx0SinNXjb9huNaFigDeJipm8,43805
+e2D/envs.py,sha256=1QnOEI2lCO3B6_EkIBBqgaXfPYLFE_u0_H6AwmZ1R9U,7171
+e2D/plots.py,sha256=_d72ZJo-GIhcJ44XCphFH288cf_ZSwWcbLh_olgGjBc,35880
+e2D/utils.py,sha256=42anOSUxvQ9SOof26VkJPsm6vN9AvckeW0U0RILzi8w,27843
+e2D/winrec.py,sha256=EFFfWYbk27NhS-rWD-BLChXvLjFW1uYZ5LkRGMj_Xo0,1116
+e2d-1.4.20.dist-info/licenses/LICENSE,sha256=hbjljn38VVW9en51B0qzRK-v2FBDijqRWbZIVTk7ipU,1094
+e2d-1.4.20.dist-info/METADATA,sha256=YOwcgB_fj4q1bHxAbh1uK-qcFEWAK8qoA4lZ4-dOFZI,9634
+e2d-1.4.20.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
+e2d-1.4.20.dist-info/top_level.txt,sha256=3vKZ-CGzNlTCpzVMmM0Ht76krCofKw7hZ0wBf-dnKdM,4
+e2d-1.4.20.dist-info/RECORD,,

{e2D-1.4.18.dist-info → e2d-1.4.20.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.0)
+Generator: setuptools (80.3.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

{e2D-1.4.18.dist-info → e2d-1.4.20.dist-info/licenses}/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2023 Riko Mari
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2025 Riccardo Mariani
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

e2D-1.4.18.dist-info/RECORD

@@ -1,13 +0,0 @@
-e2D/__init__.py,sha256=yWKj--yODW8diDHRrIDKA-lfc9e-I4NQXVaK-eJOhxw,22043
-e2D/__init__.pyi,sha256=1qEXUQC2o58Zsd8fF-UrOE0tRBbIbRG1U4vqn8iYWkI,43414
-e2D/colors.py,sha256=DgkgUdaQY41nA0VlJaMaT6VZwypG--Cw3Pwakf4OVHM,17412
-e2D/def_colors.py,sha256=3sJq2L6qFZ3svn2qEWIx0SinNXjb9huNaFigDeJipm8,43805
-e2D/envs.py,sha256=1IMQxQVYI3nx4aq1HhxeIhEyq9BKa7Vt0V4lUKL-oNA,6324
-e2D/plots.py,sha256=_d72ZJo-GIhcJ44XCphFH288cf_ZSwWcbLh_olgGjBc,35880
-e2D/utils.py,sha256=cJarYc6OTIdud7AJZHxwOhxMcEJLlgfKu60kkBu4hB8,14116
-e2D/winrec.py,sha256=EFFfWYbk27NhS-rWD-BLChXvLjFW1uYZ5LkRGMj_Xo0,1116
-e2D-1.4.18.dist-info/LICENSE,sha256=wymkNVDvj3qmjdO_rAhkRPM4t5y3_SqffGsFdgfvznU,1066
-e2D-1.4.18.dist-info/METADATA,sha256=ik2MYSLN2AWYo0yr8CTOZst4k6N1tGy06yipbqrOOSg,9611
-e2D-1.4.18.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-e2D-1.4.18.dist-info/top_level.txt,sha256=3vKZ-CGzNlTCpzVMmM0Ht76krCofKw7hZ0wBf-dnKdM,4
-e2D-1.4.18.dist-info/RECORD,,