e2D 1.4.13.1__tar.gz → 1.4.14__tar.gz

{e2d-1.4.13.1 → e2d-1.4.14}/PKG-INFO

@@ -1,9 +1,10 @@
 Metadata-Version: 2.1
 Name: e2D
-Version: 1.4.13.1
+Version: 1.4.14
 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!
-Author-email: Riccardo Mariani <ricomari2006@gmail.com>
-License: MIT
+Home-page: https://github.com/marick-py/e2D
+Author: Riccardo Mariani
+Author-email: ricomari2006@gmail.com
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent

{e2d-1.4.13.1 → e2d-1.4.14}/e2D/__init__.py

@@ -35,10 +35,20 @@ class Vector2D:
     def angle(self, new_angle) -> None:
         self.rotate(new_angle - self.angle)
 
+    @property
+    def copy(self) -> "Vector2D":
+        return Vector2D(self.x, self.y)
+
     @property
     def sign(self) -> "Vector2D":
         return Vector2D(sign(self.x), sign(self.y))
-        
+
+    @property
+    def normalize(self) -> "Vector2D":
+        if (mag:=self.length) == 0:
+            return self.copy
+        return Vector2D(self.x / mag, self.y / mag)
+
     @property
     def length(self) -> float:
         return (self.x ** 2 + self.y ** 2) ** .5
@@ -47,14 +57,6 @@ class Vector2D:
     def length_sqrd(self) -> float:
         return self.x ** 2 + self.y ** 2
 
-    def copy(self) -> "Vector2D":
-        return Vector2D(self.x, self.y)
-
-    def normalize(self) -> "Vector2D":
-        if (mag:=self.length) == 0:
-            return self.copy()
-        return Vector2D(self.x / mag, self.y / mag)
-
     def floor(self, n=1) -> "Vector2D":
         return self.__floor__(n)
 
@@ -163,20 +165,20 @@ class Vector2D:
     def sub(self, both=.0, x=.0, y=.0) -> Vector2D:
         return Vector2D(self.x - (x + both), self.y - (y + both))
     
-    def mult(self, both=.0, x=.0, y=.0) -> Vector2D:
-        return Vector2D(self.x * (x + both), self.y * (y + both))
+    def mult(self, both=1.0, x=1.0, y=1.0) -> Vector2D:
+        return Vector2D(self.x * x * both, self.y * y * both)
     
-    def pow(self, both=.0, x=.0, y=.0) -> Vector2D:
+    def pow(self, both=1.0, x=1.0, y=1.0) -> Vector2D:
         return Vector2D(self.x ** (x + both), self.y ** (y + both))
     
-    def mod(self, both=.0, x=.0, y=.0) -> Vector2D:
+    def mod(self, both=1.0, x=1.0, y=1.0) -> Vector2D:
         return Vector2D(self.x % (x + both), self.y % (y + both))
     
-    def div(self, both=.0, x=.0, y=.0) -> Vector2D:
-        return Vector2D(self.x / (x + both), self.y / (y + both))
+    def div(self, both=1.0, x=1.0, y=1.0) -> Vector2D:
+        return Vector2D(self.x / x / both, self.y / y / both)
     
-    def fdiv(self, both=.0, x=.0, y=.0) -> Vector2D:
-        return Vector2D(self.x // (x + both), self.y // (y + both))
+    def fdiv(self, both=1.0, x=1.0, y=1.0) -> Vector2D:
+        return Vector2D(self.x // x // both, self.y // y // both)
 
     # fast inplace operations     Vector2D.ioperation(both,x,y)
     def set(self, both=.0, x=.0, y=.0) -> Vector2D:
@@ -194,29 +196,29 @@ class Vector2D:
         self.y -= y + both
         return self
     
-    def imult(self, both=.0, x=.0, y=.0) -> Vector2D:
-        self.x *= x + both
-        self.y *= y + both
+    def imult(self, both=1.0, x=1.0, y=1.0) -> Vector2D:
+        self.x *= x * both
+        self.y *= y * both
         return self
     
-    def ipow(self, both=.0, x=.0, y=.0) -> Vector2D:
+    def ipow(self, both=1.0, x=1.0, y=1.0) -> Vector2D:
         self.x **= x + both
         self.y **= y + both
         return self
     
-    def imod(self, both=.0, x=.0, y=.0) -> Vector2D:
+    def imod(self, both=1.0, x=1.0, y=1.0) -> Vector2D:
         self.x %= x + both
         self.y %= y + both
         return self
     
-    def idiv(self, both=.0, x=.0, y=.0) -> Vector2D:
-        self.x /= x + both
-        self.y /= y + both
+    def idiv(self, both=1.0, x=1.0, y=1.0) -> Vector2D:
+        self.x /= x * both
+        self.y /= y * both
         return self
     
-    def ifdiv(self, both=.0, x=.0, y=.0) -> Vector2D:
-        self.x //= x + both
-        self.y //= y + both
+    def ifdiv(self, both=1.0, x=1.0, y=1.0) -> Vector2D:
+        self.x //= x * both
+        self.y //= y * both
         return self
 
     # normal operations     Vector2D + a
@@ -327,11 +329,9 @@ class Vector2D:
     def __ne__(self, other) -> bool:
         return not self.__eq__(other)
 
-    # absolute value
     def __abs__(self) -> "Vector2D":
         return Vector2D(abs(self.x), abs(self.y))
 
-    # rounding operations
     def __round__(self, n=1) -> "Vector2D":
         n = Vector2D.__normalize__(n)
         return Vector2D(round(self.x / n.x) * n.x, round(self.y / n.y) * n.y)
@@ -416,47 +416,49 @@ class Vector2D:
     def down_left_norm(cls) -> "Vector2D": return V2down_left_norm
 
     @classmethod
-    def new_zero(cls) -> "Vector2D": return V2zero.copy()
+    def new_zero(cls) -> "Vector2D": return V2zero.copy
     @classmethod
-    def new_one(cls) -> "Vector2D": return V2one.copy()
+    def new_one(cls) -> "Vector2D": return V2one.copy
     @classmethod
-    def new_two(cls) -> "Vector2D": return V2two.copy()
+    def new_two(cls) -> "Vector2D": return V2two.copy
     @classmethod
-    def new_pi(cls) -> "Vector2D": return V2pi.copy()
+    def new_pi(cls) -> "Vector2D": return V2pi.copy
     @classmethod
-    def new_inf(cls) -> "Vector2D": return V2inf.copy()
+    def new_inf(cls) -> "Vector2D": return V2inf.copy
     @classmethod
-    def new_neg_one(cls) -> "Vector2D": return V2neg_one.copy()
+    def new_neg_one(cls) -> "Vector2D": return V2neg_one.copy
     @classmethod
-    def new_neg_two(cls) -> "Vector2D": return V2neg_two.copy()
+    def new_neg_two(cls) -> "Vector2D": return V2neg_two.copy
     @classmethod
-    def new_neg_pi(cls) -> "Vector2D": return V2neg_pi.copy()
+    def new_neg_pi(cls) -> "Vector2D": return V2neg_pi.copy
     @classmethod
-    def new_neg_inf(cls) -> "Vector2D": return V2neg_inf.copy()
+    def new_neg_inf(cls) -> "Vector2D": return V2neg_inf.copy
     @classmethod
-    def new_up(cls) -> "Vector2D": return V2up.copy()
+    def new_up(cls) -> "Vector2D": return V2up.copy
     @classmethod
-    def new_right(cls) -> "Vector2D": return V2right.copy()
+    def new_right(cls) -> "Vector2D": return V2right.copy
     @classmethod
-    def new_down(cls) -> "Vector2D": return V2down.copy()
+    def new_down(cls) -> "Vector2D": return V2down.copy
     @classmethod
-    def new_left(cls) -> "Vector2D": return V2left.copy()
+    def new_left(cls) -> "Vector2D": return V2left.copy
     @classmethod
-    def new_up_right(cls) -> "Vector2D": return V2up_right.copy()
+    def new_up_right(cls) -> "Vector2D": return V2up_right.copy
     @classmethod
-    def new_down_right(cls) -> "Vector2D": return V2down_right.copy()
+    def new_down_right(cls) -> "Vector2D": return V2down_right.copy
     @classmethod
-    def new_up_left(cls) -> "Vector2D": return V2up_left.copy()
+    def new_up_left(cls) -> "Vector2D": return V2up_left.copy
     @classmethod
-    def new_down_left(cls) -> "Vector2D": return V2down_left.copy()
+    def new_down_left(cls) -> "Vector2D": return V2down_left.copy
     @classmethod
-    def new_up_right_norm(cls) -> "Vector2D": return V2up_right_norm.copy()
+    def new_up_right_norm(cls) -> "Vector2D": return V2up_right_norm.copy
     @classmethod
-    def new_down_right_norm(cls) -> "Vector2D": return V2down_right_norm.copy()
+    def new_down_right_norm(cls) -> "Vector2D": return V2down_right_norm.copy
     @classmethod
-    def new_up_left_norm(cls) -> "Vector2D": return V2up_left_norm.copy()
+    def new_up_left_norm(cls) -> "Vector2D": return V2up_left_norm.copy
     @classmethod
-    def new_down_left_norm(cls) -> "Vector2D": return V2down_left_norm.copy()
+    def new_down_left_norm(cls) -> "Vector2D": return V2down_left_norm.copy
+
+from .cvb import *
 
 V2 = Vector2D
 
@@ -482,10 +484,10 @@ V2down_right = Vector2D(1, -1)
 V2up_left = Vector2D(-1, 1)
 V2down_left = Vector2D(-1, -1)
 
-V2up_right_norm = V2up_right.normalize()
-V2down_right_norm = V2down_right.normalize()
-V2up_left_norm = V2up_left.normalize()
-V2down_left_norm = V2down_left.normalize()
+V2up_right_norm = V2up_right.normalize
+V2down_right_norm = V2down_right.normalize
+V2up_left_norm = V2up_left.normalize
+V2down_left_norm = V2down_left.normalize
 
 VECTORS_4_DIRECTIONS = (V2right, V2down, V2left, V2up)
 VECTORS_4_SEMIDIRECTIONS = (V2down_right, V2down_left, V2up_left, V2up_right)
@@ -493,6 +495,7 @@ VECTORS_4_SEMIDIRECTIONS_NORM = (V2down_right_norm, V2down_left_norm, V2up_left_
 VECTORS_8_DIRECTIONS = (V2right, V2down_right, V2down, V2down_left, V2left, V2up_left, V2up, V2up_right)
 VECTORS_8_DIRECTIONS_NORM = (V2right, V2down_right_norm, V2down, V2down_left_norm, V2left, V2up_left_norm, V2up, V2up_right_norm)
 
+
 def rgb(r:float, g:float, b:float) -> tuple[float, float, float]:
     return (r,g,b)
 

{e2d-1.4.13.1 → e2d-1.4.14}/e2D/__init__.pyi

@@ -6,7 +6,7 @@ PI_HALF : float
 PI_QUARTER : float
 PI_DOUBLE : float
 
-# reg expression to remove comments:
+# regular expression to remove comments:
 # """([\s\S]*?)"""
 
 # 
@@ -143,7 +143,31 @@ class Vector2D:
     def angle(self:"Vector2D") -> int|float: ...
 
     @angle.setter
-    def angle(self:"Vector2D", new_angle:int|float) -> None: ...
+    def angle(self:"Vector2D", argv) -> None: ...
+
+    @property
+    def copy(self:"Vector2D") -> "Vector2D":
+        """
+        # 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.
+        """
+        ...
 
     @property
     def sign(self:"Vector2D") -> "Vector2D":
@@ -186,38 +210,8 @@ class Vector2D:
             vector points in the same direction as the original vector but has non-negative components.
         """
         ...
-
-    @property
-    def length(self:"Vector2D") -> float:
-        ...
-
-    @property
-    def length_sqrd(self:"Vector2D") -> float:
-        ...
-
-    def copy(self:"Vector2D") -> "Vector2D":
-        """
-        # 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.
-        """
-        ...
     
+    @property
     def normalize(self:"Vector2D") -> "Vector2D":
         """
         # Vector Normalization
@@ -248,6 +242,14 @@ class Vector2D:
         """
         ...
     
+    @property
+    def length(self:"Vector2D") -> float:
+        ...
+
+    @property
+    def length_sqrd(self:"Vector2D") -> float:
+        ...
+
     def floor(self:"Vector2D", n:"int|float|Vector2D"=1) -> "Vector2D":
         ...
 
@@ -491,7 +493,7 @@ class Vector2D:
                 If None, the vector is rotated around the origin (0, 0).
 
         ## Returns:
-            Vector2D or V2: The rotated vector.
+            None
 
         ## Example:
             v = Vector2D(3, 4)
@@ -579,32 +581,32 @@ class Vector2D:
     
     def sub(self, both:int|float=.0, x:int|float=.0, y:int|float=.0) -> Vector2D: ...
     
-    def mult(self, both:int|float=.0, x:int|float=.0, y:int|float=.0) -> Vector2D: ...
+    def mult(self, both:int|float=1.0, x:int|float=1.0, y:int|float=1.0) -> Vector2D: ...
     
-    def pow(self, both:int|float=.0, x:int|float=.0, y:int|float=.0) -> Vector2D: ...
+    def pow(self, both:int|float=1.0, x:int|float=1.0, y:int|float=1.0) -> Vector2D: ...
     
-    def mod(self, both:int|float=.0, x:int|float=.0, y:int|float=.0) -> Vector2D: ...
+    def mod(self, both:int|float=1.0, x:int|float=1.0, y:int|float=1.0) -> Vector2D: ...
     
-    def div(self, both:int|float=.0, x:int|float=.0, y:int|float=.0) -> Vector2D: ...
+    def div(self, both:int|float=1.0, x:int|float=1.0, y:int|float=1.0) -> Vector2D: ...
     
-    def fdiv(self, both:int|float=.0, x:int|float=.0, y:int|float=.0) -> Vector2D: ...
+    def fdiv(self, both:int|float=1.0, x:int|float=1.0, y:int|float=1.0) -> Vector2D: ...
 
     # fast inplace operations     Vector2D.ioperation(both,x,y)
-    def set(self, both=int|float, x:int|float, y:int|float) -> Vector2D: ...
+    def set(self, both:int|float=.0, x:int|float=.0, y:int|float=.0) -> Vector2D: ...
 
-    def iadd(self, both:int|float, x:int|float, y=int|float) -> Vector2D: ...
+    def iadd(self, both:int|float=.0, x:int|float=.0, y:int|float=.0) -> Vector2D: ...
     
-    def isub(self, both:int|float, x:int|float, y=int|float) -> Vector2D: ...
+    def isub(self, both:int|float=.0, x:int|float=.0, y:int|float=.0) -> Vector2D: ...
     
-    def imult(self, both:int|float, x:int|float, y=int|float) -> Vector2D: ...
+    def imult(self, both:int|float=1.0, x:int|float=1.0, y:int|float=1.0) -> Vector2D: ...
     
-    def ipow(self, both:int|float, x:int|float, y=int|float) -> Vector2D: ...
+    def ipow(self, both:int|float=1.0, x:int|float=1.0, y:int|float=1.0) -> Vector2D: ...
     
-    def imod(self, both:int|float, x:int|float, y=int|float) -> Vector2D: ...
+    def imod(self, both:int|float=1.0, x:int|float=1.0, y:int|float=1.0) -> Vector2D: ...
     
-    def idiv(self, both:int|float, x:int|float, y=int|float) -> Vector2D: ...
+    def idiv(self, both:int|float=1.0, x:int|float=1.0, y:int|float=1.0) -> Vector2D: ...
     
-    def ifdiv(self, both:int|float, x:int|float, y=int|float) -> Vector2D: ...
+    def ifdiv(self, both:int|float=1.0, x:int|float=1.0, y:int|float=1.0) -> Vector2D: ...
 
     # normal operations     Vector2D + a
     def __add__(self:"Vector2D", other:"int|float|Vector2D|list|tuple") -> "Vector2D": ...

{e2d-1.4.13.1 → e2d-1.4.14}/e2D/envs.py

@@ -5,7 +5,7 @@ from .utils import *
 import pygame as pg
 
 """  CODE EXAMPLE FOR RootEnv
-from e2D.envs import *
+from e2D.envs import * #type: ignore
 
 class Env(DefEnv):
     def __init__(self) -> None:

{e2d-1.4.13.1 → e2d-1.4.14}/e2D/plots.py

@@ -127,8 +127,8 @@ class MathFunction(Function):
                  id:int|str,
                  function:Callable[[int|float, int|float], int|float],
                  domain:list[float]=[-np.inf, np.inf],
-                 codomain:list[float]=[-np.inf, np.inf], colo
-                 :list[float]|tuple[float,float,float]=(255,255,255)) -> None:
+                 codomain:list[float]=[-np.inf, np.inf],
+                 color:list[float]|tuple[float,float,float]=(255,255,255)) -> None:
         super().__init__()
         self.id = id
         self.color = color
@@ -398,7 +398,7 @@ class Plot:
         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 - 2**(-.1*self.current_zoom) * self.__y_axis_multiplier__
+        self.top_left_plot_coord = self.current_offset - 2**(self.current_zoom.mult(-.1)) * 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

{e2d-1.4.13.1 → e2d-1.4.14}/e2D/utils.py

@@ -3,6 +3,8 @@ from typing import Any, Callable, Literal
 import pygame as pg
 from e2D import *
 
+import math as _mt
+
 pg.font.init()
 
 __KEY_MODE_TYPES_DICT__ = dict(zip(["pressed", "just_pressed", "just_released"], range(3)))
@@ -95,6 +97,7 @@ class Util:
         self.rootEnv = None
         self.surface : pg.Surface
         self.id : int|str
+        self.is_hovered :bool= False
     def draw(self) -> None: pass
     def update(self) -> None: pass
 
@@ -153,14 +156,15 @@ class InputCell(Util):
             if self.border_width:
                 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.get_time_from_start() * 10)]*3, self.margin_rect, self.border_width if self.border_width else 10, -1, *self.border_radius)
+            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)
 
         self.surface.blit(self.text_surface, self.position())
         
     def update(self) -> None:
+        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.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.is_hovered:
                 self.rootEnv.selected_util = self if self.rootEnv.selected_util != self else None
                 self.update_text()
         if self.rootEnv.selected_util == self:

{e2d-1.4.13.1 → e2d-1.4.14}/e2D/winrec.py

@@ -18,7 +18,7 @@ class WinRec:
         return self.rootEnv.current_frame/self.fps
 
     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)}]"
+        text = f"[cfps:{self.rootEnv.current_frame} || realtime:{round(self.get_rec_seconds(),2)} || apptime:{round(self.rootEnv.runtime_seconds,2)}]"
         pg.display.set_caption(text)
         if draw_on_screen: self.rootEnv.print(text, self.rootEnv.screen_size, pivot_position='bottom_right')
     

{e2d-1.4.13.1 → e2d-1.4.14}/e2D.egg-info/PKG-INFO

@@ -1,9 +1,10 @@
 Metadata-Version: 2.1
 Name: e2D
-Version: 1.4.13.1
+Version: 1.4.14
 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!
-Author-email: Riccardo Mariani <ricomari2006@gmail.com>
-License: MIT
+Home-page: https://github.com/marick-py/e2D
+Author: Riccardo Mariani
+Author-email: ricomari2006@gmail.com
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent

{e2d-1.4.13.1 → e2d-1.4.14}/e2D.egg-info/SOURCES.txt

@@ -1,8 +1,7 @@
 LICENSE
 README.md
 pyproject.toml
-setup.py
-e2D/Cmain.c
+setup.cfg
 e2D/__init__.py
 e2D/__init__.pyi
 e2D/envs.py

e2d-1.4.14/pyproject.toml

@@ -0,0 +1,6 @@
+[build-system]
+requires = [
+  "setuptools>=54",
+  "wheel"
+]
+build-backend = "setuptools.build_meta"

e2d-1.4.14/setup.cfg

@@ -0,0 +1,26 @@
+[metadata]
+name = e2D
+version = 1.4.14
+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!
+long_description = file: README.md
+long_description_content_type = text/markdown
+url = https://github.com/marick-py/e2D
+classifiers = 
+	Programming Language :: Python :: 3
+	License :: OSI Approved :: MIT License
+	Operating System :: OS Independent
+
+[options]
+packages = find:
+python_requires = >= 3.9
+install_requires = 
+	numpy
+	pygame
+include_package_data = True
+
+[egg_info]
+tag_build = 
+tag_date = 0
+