e2D 1.4.14__tar.gz → 1.4.16__tar.gz

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

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

@@ -458,7 +458,6 @@ class Vector2D:
     @classmethod
     def new_down_left_norm(cls) -> "Vector2D": return V2down_left_norm.copy
 
-from .cvb import *
 
 V2 = Vector2D
 
@@ -469,10 +468,10 @@ V2two = Vector2D(2.0, 2.0)
 V2pi = Vector2D(PI, PI)
 V2inf = Vector2D(float("inf"), float("inf"))
 
-V2neg_one = Vector2D(1.0, 1.0)
-V2neg_two = Vector2D(2.0, 2.0)
-V2neg_pi = Vector2D(PI, PI)
-V2neg_inf = Vector2D(float("inf"), float("inf"))
+V2neg_one = V2one.mult(-1)
+V2neg_two = V2two.mult(-1)
+V2neg_pi = V2pi.mult(-1)
+V2neg_inf = V2inf.mult(-1)
 
 V2up = Vector2D(0, 1)
 V2right = Vector2D(1, 0)

e2d-1.4.16/e2D/colors.py

@@ -0,0 +1,463 @@
+from colorsys import hsv_to_rgb as __hsv_to_rgb_def__, hls_to_rgb as __hls_to_rgb_def__, rgb_to_hls as __rgb_to_hls__, rgb_to_hsv as __rgb_to_hsv__
+from typing import Any, Callable, Generator, Literal
+from pygame.color import Color as __color_pygame__
+from random import randint as __randint__
+
+RGB_COLOR_MODE = "rgb"
+RGBA_COLOR_MODE = "rgba"
+BGR_COLOR_MODE = "bgr"
+BGRA_COLOR_MODE = "bgra"
+GRAY_COLOR_MODE = "g"
+HSV_COLOR_MODE = "hsv"
+HLS_COLOR_MODE = "hls"
+# CMYK_COLOR_MODE = "cmyk"
+# LAB_COLOR_MODE = "lab"
+
+__LITERAL_COLOR_MODES__ = Literal["rgb","rgba","bgr","bgra","g","hsv","hls"] #,"cmyk","lab"]
+
+def __hsv_to_rgb__(h:int|float, s:int|float, v:int|float) -> tuple[int|float, int|float, int|float]:
+    r,g,b = __hsv_to_rgb_def__(h, s, v)
+    return r*255, g*255, b*255
+
+def __hls_to_rgb__(h:int|float, s:int|float, v:int|float) -> tuple[int|float, int|float, int|float]:
+    r,g,b = __hls_to_rgb_def__(h, s, v)
+    return r*255, g*255, b*255
+    
+__conversion_table__ :dict[__LITERAL_COLOR_MODES__, dict[__LITERAL_COLOR_MODES__, Callable]]= {
+    "rgb": {
+        "rgba": lambda r,g,b: (r, g, b, 255.0),
+        "bgr": lambda r,g,b: (b, g, r),
+        "bgra": lambda r,g,b: (b, g, r, 255.0),
+        "g": lambda r,g,b: (.2989*r+.587*g+.114*b,),
+        "hsv": lambda r,g,b: __rgb_to_hsv__(r/255.0, g/255.0, b/255.0),
+        "hls": lambda r,g,b: __rgb_to_hls__(r/255.0, g/255.0, b/255.0),
+        },
+    "rgba": {
+        "rgb": lambda r,g,b,a: (r, g, b),
+        "bgr": lambda r,g,b,a: (b, g, r),
+        "bgra": lambda r,g,b,a: (b, g, r, a),
+        "g": lambda r,g,b,a: (.2989*r+.587*g+.114*b,),
+        "hsv": lambda r,g,b,a: __rgb_to_hsv__(r/255.0, g/255.0, b/255.0),
+        "hls": lambda r,g,b,a: __rgb_to_hls__(r/255.0, g/255.0, b/255.0),
+        },
+    "bgr": {
+        "rgb": lambda b,g,r: (r, g, b),
+        "rgba": lambda b,g,r: (r, g, b, 255.0),
+        "bgra": lambda b,g,r: (b, g, r, 255.0),
+        "g": lambda b,g,r: (.2989*r+.587*g+.114*b,),
+        "hsv": lambda b,g,r: __rgb_to_hsv__(r/255.0, g/255.0, b/255.0),
+        "hls": lambda b,g,r: __rgb_to_hls__(r/255.0, g/255.0, b/255.0),
+        },
+    "bgra": {
+        "rgb": lambda b,g,r,a: (r, g, b),
+        "rgba": lambda b,g,r,a: (b, g, r, a),
+        "bgr": lambda b,g,r,a: (b, g, r),
+        "g": lambda b,g,r,a: (.2989*r+.587*g+.114*b,),
+        "hsv": lambda b,g,r,a: __rgb_to_hsv__(r/255.0, g/255.0, b/255.0),
+        "hls": lambda b,g,r,a: __rgb_to_hls__(r/255.0, g/255.0, b/255.0),
+        },
+    "g": {
+        "rgb": lambda g: (g, g, g),
+        "rgba": lambda g: (g, g, g, 255.0),
+        "bgr": lambda g: (g, g, g),
+        "bgra": lambda g: (g, g, g, 255.0),
+        "hsv": lambda g: __rgb_to_hsv__(g/255.0, g/255.0, g/255.0),
+        "hls": lambda g: __rgb_to_hls__(g/255.0, g/255.0, g/255.0),
+    },
+    "hsv": {
+        "rgb": lambda h,s,v: __hsv_to_rgb__(h,s,v),
+        "rgba": lambda h,s,v: (*__hsv_to_rgb__(h,s,v), 255.0),
+        "bgr": lambda h,s,v: __hsv_to_rgb__(h,s,v)[::-1],
+        "bgra": lambda h,s,v: (*__hsv_to_rgb__(h,s,v)[::-1], 255.0),
+        "g": lambda h,s,v: (sum(m*v for m,v in zip((.2989, .587, .114), __hsv_to_rgb__(h,s,v))),),
+        "hls": lambda h,s,v: __rgb_to_hls__(*__hsv_to_rgb_def__(h,s,v)),
+        },
+    "hls": {
+        "rgb": lambda h,l,s: __hls_to_rgb__(h,l,s),
+        "rgba": lambda h,l,s: (*__hls_to_rgb__(h,l,s), 255.0),
+        "bgr": lambda h,l,s: __hls_to_rgb__(h,l,s)[::-1],
+        "bgra": lambda h,l,s: (*__hls_to_rgb__(h,l,s)[::-1], 255.0),
+        "g": lambda h,l,s: (sum(m*v for m,v in zip((.2989, .587, .114), __hls_to_rgb__(h,l,s))),),
+        "hsv": lambda h,l,s: __rgb_to_hsv__(*__hls_to_rgb_def__(h,l,s)),
+        },
+}
+
+class Color:
+    def __init__(self, *values, mode:__LITERAL_COLOR_MODES__=RGB_COLOR_MODE) -> None:
+        self.__dict__ = dict(zip(mode, values))
+        self.mode :__LITERAL_COLOR_MODES__= mode
+    
+    @classmethod
+    def new_rgb(cls, r:int|float, g:int|float, b:int|float) -> "Color":
+        return Color(r,g,b, mode=RGB_COLOR_MODE)
+    @classmethod
+    def new_rgba(cls, r:int|float, g:int|float, b:int|float, a:int|float) -> "Color":
+        return Color(r,g,b,a, mode=RGBA_COLOR_MODE)
+    @classmethod
+    def new_bgr(cls, b:int|float, g:int|float, r:int|float) -> "Color":
+        return Color(b,g,r, mode=BGR_COLOR_MODE)
+    @classmethod
+    def new_bgra(cls, b:int|float, g:int|float, r:int|float, a:int|float) -> "Color":
+        return Color(b,g,r,a, mode=BGRA_COLOR_MODE)
+    @classmethod
+    def new_g(cls, g) -> "Color":
+        return Color(g, mode=GRAY_COLOR_MODE)
+    @classmethod
+    def new_hsv(cls, h:int|float, s:int|float, v:int|float) -> "Color":
+        return Color(h,s,v, mode=HSV_COLOR_MODE)
+    @classmethod
+    def new_hls(cls, h:int|float, l:int|float, s:int|float) -> "Color":
+        return Color(h,l,s, mode=HLS_COLOR_MODE)
+    # @classmethod
+    # def new_cmyk(cls, c:int|float, m:int|float, y:int|float, k:int|float) -> Color:
+    #     return Color(c,m,y,k, mode=CMYK_COLOR_MODE)
+    # @classmethod
+    # def new_lab(cls, l:int|float, a:int|float, b:int|float) -> Color:
+    #     return Color(l,a,b, mode=LAB_COLOR_MODE)
+
+    @property
+    def values(self) -> tuple[int|float, ...]:
+        return tuple(self.__dict__.values())[:-1]
+
+    @property
+    def keys(self) -> tuple[str, ...]:
+        return tuple(self.__dict__.keys())[:-1]
+    
+    @property
+    def items(self) -> tuple[tuple[str, int|float], ...]:
+        return tuple(self.__dict__.items())[:-1]
+
+    def copy(self) -> "Color":
+        return Color(*self.values, mode=self.mode)
+
+    def to_mode(self, mode:__LITERAL_COLOR_MODES__) -> "Color":
+        if mode == self.mode: return self.copy()
+        return Color(*__conversion_table__[self.mode][mode](*self.values), mode=mode)
+
+    def to_rgb(self) -> "Color":
+        if self.mode == RGB_COLOR_MODE: return self.copy()
+        return Color(*__conversion_table__[self.mode][RGB_COLOR_MODE](*self.values), mode=RGB_COLOR_MODE)
+    def to_rgba(self) -> "Color":
+        if self.mode == RGBA_COLOR_MODE: return self.copy()
+        return Color(*__conversion_table__[self.mode][RGBA_COLOR_MODE](*self.values), mode=RGBA_COLOR_MODE)
+    def to_bgr(self) -> "Color":
+        if self.mode == BGR_COLOR_MODE: return self.copy()
+        return Color(*__conversion_table__[self.mode][BGR_COLOR_MODE](*self.values), mode=BGR_COLOR_MODE)
+    def to_bgra(self) -> "Color":
+        if self.mode == BGRA_COLOR_MODE: return self.copy()
+        return Color(*__conversion_table__[self.mode][BGRA_COLOR_MODE](*self.values), mode=BGRA_COLOR_MODE)
+    def to_g(self) -> "Color":
+        if self.mode == GRAY_COLOR_MODE: return self.copy()
+        return Color(*__conversion_table__[self.mode][GRAY_COLOR_MODE](*self.values), mode=GRAY_COLOR_MODE)
+    def to_hsv(self) -> "Color":
+        if self.mode == HSV_COLOR_MODE: return self.copy()
+        return Color(*__conversion_table__[self.mode][HSV_COLOR_MODE](*self.values), mode=HSV_COLOR_MODE)
+    def to_hls(self) -> "Color":
+        if self.mode == HLS_COLOR_MODE: return self.copy()
+        return Color(*__conversion_table__[self.mode][HLS_COLOR_MODE](*self.values), mode=HLS_COLOR_MODE)
+
+    def __repr__(self) -> str:
+        return self.__str__()
+    
+    def __str__(self) -> str:
+        return "Color(" + ", ".join(f"{k}:{v}" for k, v in self.items) + ")"
+
+    def __call__(self) -> __color_pygame__:
+        return __color_pygame__(*map(int, self.to_rgba().values))
+    
+    # fast operations     Vector2D.operation(both,x,y)
+    def add(self, all3=.0, r=.0, g=.0, b=.0) -> "Color":
+        c_color = self.to_rgb()
+        return Color(c_color.r + (r + all3), c_color.g + (g + all3), c_color.b + (b + all3)).to_mode(self.mode) # type: ignore
+    
+    def sub(self, all3=.0, r=.0, g=.0, b=.0) -> "Color":
+        c_color = self.to_rgb()
+        return Color(c_color.r - (r + all3), c_color.g - (g + all3), c_color.b - (b + all3)).to_mode(self.mode) # type: ignore
+    
+    def mult(self, all3=1.0, r=1.0, g=1.0, b=1.0) -> "Color":
+        c_color = self.to_rgb()
+        return Color(c_color.r * r * all3, c_color.g * g * all3, c_color.b * b * all3).to_mode(self.mode) # type: ignore
+    
+    def pow(self, all3=1.0, r=1.0, g=1.0, b=1.0) -> "Color":
+        c_color = self.to_rgb()
+        return Color(c_color.r ** (r + all3), c_color.g ** (g + all3), c_color.b ** (b + all3)).to_mode(self.mode) # type: ignore
+    
+    def mod(self, all3=1.0, r=1.0, g=1.0, b=1.0) -> "Color":
+        c_color = self.to_rgb()
+        return Color(c_color.r % (r + all3), c_color.g % (g + all3), c_color.b % (b + all3)).to_mode(self.mode) # type: ignore
+    
+    def div(self, all3=1.0, r=1.0, g=1.0, b=1.0) -> "Color":
+        c_color = self.to_rgb()
+        return Color(c_color.r / r / all3, c_color.g / g / all3, c_color.b / b / all3).to_mode(self.mode) # type: ignore
+    
+    def fdiv(self, all3=1.0, r=1.0, g=1.0, b=1.0) -> "Color":
+        c_color = self.to_rgb()
+        return Color(c_color.r // r // all3, c_color.g // g // all3, c_color.b // b // all3).to_mode(self.mode) # type: ignore
+
+    # fast inplace operations     Vector2D.ioperation(both,x,y)
+    def set(self, both=.0, x=.0, y=.0) -> "Color":
+        self.x = x + both
+        self.y = y + both
+        return self
+
+    def iadd(self, all3=.0, r=.0, g=.0, b=.0) -> "Color":
+        c_color = self.to_rgb()
+        c_color.r += r + all3 # type: ignore
+        c_color.g += g + all3 # type: ignore
+        c_color.b += b + all3 # type: ignore
+        self.__dict__ = c_color.to_mode(self.mode).__dict__
+        return self
+    
+    def isub(self, all3=.0, r=.0, g=.0, b=.0) -> "Color":
+        c_color = self.to_rgb()
+        c_color.r -= r + all3 # type: ignore
+        c_color.g -= g + all3 # type: ignore
+        c_color.b -= b + all3 # type: ignore
+        self.__dict__ = c_color.to_mode(self.mode).__dict__
+        return self
+    
+    def imult(self, all3=1.0, r=1.0, g=1.0, b=1.0) -> "Color":
+        c_color = self.to_rgb()
+        c_color.r *= r * all3 # type: ignore
+        c_color.g *= g * all3 # type: ignore
+        c_color.b *= b * all3 # type: ignore
+        self.__dict__ = c_color.to_mode(self.mode).__dict__
+        return self
+    
+    def ipow(self, all3=1.0, r=1.0, g=1.0, b=1.0) -> "Color":
+        c_color = self.to_rgb()
+        c_color.r **= r + all3 # type: ignore
+        c_color.g **= g + all3 # type: ignore
+        c_color.b **= b + all3 # type: ignore
+        self.__dict__ = c_color.to_mode(self.mode).__dict__
+        return self
+    
+    def imod(self, all3=1.0, r=1.0, g=1.0, b=1.0) -> "Color":
+        c_color = self.to_rgb()
+        c_color.r %= r + all3 # type: ignore
+        c_color.g %= g + all3 # type: ignore
+        c_color.b %= b + all3 # type: ignore
+        self.__dict__ = c_color.to_mode(self.mode).__dict__
+        return self
+    
+    def idiv(self, all3=1.0, r=1.0, g=1.0, b=1.0) -> "Color":
+        c_color = self.to_rgb()
+        c_color.r /= r * all3 # type: ignore
+        c_color.g /= g * all3 # type: ignore
+        c_color.b /= b * all3 # type: ignore
+        self.__dict__ = c_color.to_mode(self.mode).__dict__
+        return self
+    
+    def ifdiv(self, all3=1.0, r=1.0, g=1.0, b=1.0) -> "Color":
+        c_color = self.to_rgb()
+        c_color.r //= r * all3 # type: ignore
+        c_color.g //= g * all3 # type: ignore
+        c_color.b //= b * all3 # type: ignore
+        self.__dict__ = c_color.to_mode(self.mode).__dict__
+        return self
+
+    # normal operations     Vector2D + a
+    def __add__(self, other) -> "Color":
+        other = Color.__normalize__(other)
+        c_color = self.to_rgb()
+        return Color(c_color.r + other.r, c_color.g + other.g, c_color.b + other.b).to_mode(self.mode) # type: ignore
+    
+    def __sub__(self, other) -> "Color":
+        other = Color.__normalize__(other)
+        c_color = self.to_rgb()
+        return Color(c_color.r - other.r, c_color.g - other.g, c_color.b - other.b).to_mode(self.mode) # type: ignore
+    
+    def __mul__(self, other) -> "Color":
+        other = Color.__normalize__(other)
+        c_color = self.to_rgb()
+        return Color(c_color.r * other.r, c_color.g * other.g, c_color.b * other.b).to_mode(self.mode) # type: ignore
+
+    def __mod__(self, other) -> "Color":
+        other = Color.__normalize__(other)
+        c_color = self.to_rgb()
+        return Color(c_color.r % other.r, c_color.g % other.g, c_color.b % other.b).to_mode(self.mode) # type: ignore
+    
+    def __pow__(self, other) -> "Color":
+        other = Color.__normalize__(other)
+        c_color = self.to_rgb()
+        return Color(c_color.r ** other.r, c_color.g ** other.g, c_color.b ** other.b).to_mode(self.mode) # type: ignore
+
+    def __truediv__(self, other) -> "Color":
+        other = Color.__normalize__(other)
+        c_color = self.to_rgb()
+        return Color(c_color.r / other.r, c_color.g / other.g, c_color.b / other.b).to_mode(self.mode) # type: ignore
+
+    def __floordiv__(self, other) -> "Color":
+        other = Color.__normalize__(other)
+        c_color = self.to_rgb()
+        return Color(c_color.r // other.r, c_color.g // other.g, c_color.b // other.b).to_mode(self.mode) # type: ignore
+    
+    # right operations      a + Vector2D
+    def __radd__(self, other) -> "Color":
+        return self.__add__(other)
+    
+    def __rsub__(self, other) -> "Color":
+        other = Color.__normalize__(other)
+        c_color = self.to_rgb()
+        return Color(other.r - c_color.r, other.g - c_color.g, other.b - c_color.b).to_mode(self.mode) # type: ignore
+    
+    def __rmul__(self, other) -> "Color":
+        return self.__mul__(other)
+
+    def __rmod__(self, other) -> "Color":
+        other = Color.__normalize__(other)
+        c_color = self.to_rgb()
+        return Color(other.r % c_color.r, other.g % c_color.g, other.b % c_color.b).to_mode(self.mode) # type: ignore
+    
+    def __rpow__(self, other) -> "Color":
+        other = Color.__normalize__(other)
+        c_color = self.to_rgb()
+        return Color(other.r ** c_color.r, other.g ** c_color.g, other.b ** c_color.b).to_mode(self.mode) # type: ignore
+
+    def __rtruediv__(self, other) -> "Color":
+        other = Color.__normalize__(other)
+        c_color = self.to_rgb()
+        return Color(other.r / c_color.r, other.g / c_color.g, other.b / c_color.b).to_mode(self.mode) # type: ignore
+
+    def __rfloordiv__(self, other) -> "Color":
+        other = Color.__normalize__(other)
+        c_color = self.to_rgb()
+        return Color(other.r // c_color.r, other.g // c_color.g, other.b // c_color.b).to_mode(self.mode) # type: ignore
+    
+    # in-place operations   Vector2D += a
+    def __iadd__(self, other) -> "Color":
+        other = Color.__normalize__(other)
+        c_color = self.to_rgb()
+        c_color.r += other.r # type: ignore
+        c_color.g += other.g # type: ignore
+        c_color.b += other.b # type: ignore
+        self.__dict__ = c_color.to_mode(self.mode).__dict__
+        return self
+
+    def __isub__(self, other) -> "Color":
+        other = Color.__normalize__(other)
+        c_color = self.to_rgb()
+        c_color.r -= other.r # type: ignore
+        c_color.g -= other.g # type: ignore
+        c_color.b -= other.b # type: ignore
+        self.__dict__ = c_color.to_mode(self.mode).__dict__
+        return self
+    
+    def __imul__(self, other) -> "Color":
+        other = Color.__normalize__(other)
+        c_color = self.to_rgb()
+        c_color.r *= other.r # type: ignore
+        c_color.g *= other.g # type: ignore
+        c_color.b *= other.b # type: ignore
+        self.__dict__ = c_color.to_mode(self.mode).__dict__
+        return self
+
+    def __itruediv__(self, other) -> "Color":
+        other = Color.__normalize__(other)
+        c_color = self.to_rgb()
+        c_color.r **= other.r # type: ignore
+        c_color.g **= other.g # type: ignore
+        c_color.b **= other.b # type: ignore
+        self.__dict__ = c_color.to_mode(self.mode).__dict__
+        return self
+    
+    def __imod__(self, other) -> "Color":
+        other = Color.__normalize__(other)
+        c_color = self.to_rgb()
+        c_color.r %= other.r # type: ignore
+        c_color.g %= other.g # type: ignore
+        c_color.b %= other.b # type: ignore
+        self.__dict__ = c_color.to_mode(self.mode).__dict__
+        return self
+    
+    def __ipow__(self, other) -> "Color":
+        other = Color.__normalize__(other)
+        c_color = self.to_rgb()
+        c_color.r /= other.r # type: ignore
+        c_color.g /= other.g # type: ignore
+        c_color.b /= other.b # type: ignore
+        self.__dict__ = c_color.to_mode(self.mode).__dict__
+        return self
+
+    def __ifloordiv__(self, other) -> "Color":
+        other = Color.__normalize__(other)
+        c_color = self.to_rgb()
+        c_color.r //= other.r # type: ignore
+        c_color.g //= other.g # type: ignore
+        c_color.b //= other.b # type: ignore
+        self.__dict__ = c_color.to_mode(self.mode).__dict__
+        return self
+
+    # comparasion
+    def __eq__(self, other) -> bool:
+        try: other = Color.__normalize__(other)
+        except: return False
+        c_color = self.to_rgb()
+        return c_color.r == other.r and c_color.g == other.g and c_color.b == other.b # type: ignore
+
+    def __ne__(self, other) -> bool:
+        return not self.__eq__(other)
+
+    def __abs__(self) -> "Color":
+        c_color = self.to_rgb()
+        return Color(abs(c_color.r), abs(c_color.g), abs(c_color.b)).to_mode(self.mode) # type: ignore
+
+    def __round__(self, n=1) -> "Color":
+        n = Color.__normalize__(n)
+        c_color = self.to_rgb()
+        return Color(round(c_color.r / n.r) * n.r, round(c_color.g / n.g) * n.g, round(c_color.b / n.b) * n.b).to_mode(self.mode) # type: ignore
+
+    def __floor__(self, n=1) -> "Color":
+        n = Color.__normalize__(n)
+        c_color = self.to_rgb()
+        return Color((c_color.r / n.r).__floor__() * n.r, (c_color.g / n.g).__floor__() * n.g, (c_color.b / n.b).__floor__() * n.b).to_mode(self.mode) # type: ignore
+
+    def __ceil__(self, n=1) -> "Color":
+        n = Color.__normalize__(n)
+        c_color = self.to_rgb()
+        return Color((c_color.r / n.r).__ceil__() * n.r, (c_color.g / n.g).__ceil__() * n.g, (c_color.b / n.b).__ceil__() * n.b).to_mode(self.mode) # type: ignore
+    
+    def __float__(self) -> "Color":
+        c_color = self.to_rgb()
+        return Color(float(c_color.r), float(c_color.g), float(c_color.b)).to_mode(self.mode) # type: ignore
+
+    def __getitem__(self, n) -> int|float:
+        return self.values[n] if isinstance(n, int) else self.values[self.keys.index(n)]
+    
+    def __iter__(self) -> Generator[float, Any, None]:
+        for val in self.values:
+            yield val
+    
+    @classmethod
+    def __normalize__(cls, other) -> "Color":
+        if isinstance(other, Color):
+            return other
+        if isinstance(other, (int, float)):
+            return cls(other, other, other)
+        if isinstance(other, (list, tuple)):
+            return cls(*other[:3])
+        try:
+            return cls(*other.values, mode=other.mode)
+        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 white(cls) -> "Color": return Color(255,255,255)
+    @classmethod
+    def black(cls) -> "Color": return Color(0,0,0)
+    @classmethod
+    def red(cls) -> "Color": return Color(255,0,0)
+    @classmethod
+    def green(cls) -> "Color": return Color(0,255,0)
+    @classmethod
+    def blue(cls) -> "Color": return Color(0,0,255)
+
+    @classmethod
+    def randomize(cls) -> "Color":
+        return Color(__randint__(0,255), __randint__(0,255), __randint__(0,255))
+
+WHITE_COLOR_PYG = Color.white()()
+BLACK_COLOR_PYG = Color.black()()
+RED_COLOR_PYG = Color.red()()
+GREEN_COLOR_PYG = Color.green()()
+BLUE_COLOR_PYG = Color.blue()()

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

@@ -38,7 +38,7 @@ class RootEnv:
     def __init__(self,
                  screen_size : Vector2D = Vector2D(1920, 1080),
                  target_fps : int = 60,
-                 show_fps = True,
+                 show_fps : bool = True,
                  quit_on_key_pressed : None|int = pg.K_x,
                  vsync : bool = True,
                  window_flags : int = pg.DOUBLEBUF,
@@ -59,12 +59,11 @@ class RootEnv:
         self.current_frame = 0
         self.show_fps = show_fps
         self.events :list[pg.event.Event]= []
-        self.background_color = rgb(0,0,0)
+        self.background_color = Color.black()
         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 screen_size(self) -> Vector2D:
@@ -72,6 +71,7 @@ class RootEnv:
 
     @screen_size.setter
     def screen_size(self, new_size:Vector2D) -> None:
+        self.__screen_size__ = new_size
         self.screen = pg.display.set_mode(self.__screen_size__(), vsync=self.__vsync__, flags=self.__flags__)
 
     @property
@@ -81,22 +81,23 @@ class RootEnv:
     def get_teoric_max_fps(self) -> float:
         rawdelta = self.clock.get_rawtime()
         return (1000 / rawdelta) if rawdelta != 0 else 1
-    
+
     def update_screen_mode(self, vsync:None|bool=None, flags=None) -> None:
-        pass
-    
+        self.__vsync__ = vsync
+        self.__flags__ = flags
+
     def sleep(self, seconds:int|float, precise_delay=False) -> None:
         if precise_delay:
             pg.time.delay(seconds * 1000)
         else:
             pg.time.wait(seconds * 1000)
-    
+
     def add_utils(self, *utils:Util) -> None:
         for util in utils:
             if util.surface == None: util.surface = self.screen
             util.rootEnv = self
             self.utils[util.id] = util
-    
+
     def remove_utils(self, *utils:int|str|Util) -> None:
         for uid in utils:
             if uid in self.utils:
@@ -105,55 +106,55 @@ class RootEnv:
                 del self.utils[uid.id]
             else:
                 raise Exception(f"Unknown util type: {uid}")
-    
+
     @property
     def runtime_seconds(self) -> float:
         return pg.time.get_ticks() / 1e3
-    
+
     def init(self, sub_env:DefEnv) -> None:
         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())
-    
+
     def print(self, 
             text : str, 
             position : Vector2D, 
-            color : tuple[float,float,float] = (255,255,255), 
+            color : Color = Color.white(), 
             pivot_position : __LITERAL_PIVOT_POSITIONS__ = "top_left",
             font : pg.font.Font = FONT_ARIAL_32,
-            bg_color : None|tuple[int,int,int]|list[int] = None,
-            border_color : None|tuple[int,int,int]|list[int] = (255,255,255),
-            border_width : float = 0,
+            bg_color : None|Color = None,
+            border_color : Color = Color.white(),
+            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)
+        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
         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, (pivotted_position - margin)() + size(), 0, -1, *border_radius)
+            pg.draw.rect(surface, bg_color(), (pivotted_position - margin)() + size(), 0, -1, *border_radius)
         if border_width:
-            pg.draw.rect(surface, border_color, (pivotted_position - margin)() + size(), border_width, -1, *border_radius)
+            pg.draw.rect(surface, border_color(), (pivotted_position - margin)() + size(), border_width, -1, *border_radius)
         surface.blit(text_box, pivotted_position())
 
     def __draw__(self) -> None:
         self.clock.tick(self.target_fps)
         self.current_fps = self.clock.get_fps()
         if self.clear_screen_each_frame: self.clear()
-        
+
         self.env.draw()
         for util in self.utils.values(): util.draw()
-        
-        if self.show_fps: self.print(str(round(self.current_fps,2)), self.screen_size * .01, bg_color=(0,0,0))
+
+        if self.show_fps: self.print(str(round(self.current_fps,2)), self.screen_size * .01, bg_color=Color.black())
         pg.display.flip()
-    
+
     def __update__(self) -> None:
         self.mouse.update()
         self.keyboard.update()
@@ -168,4 +169,5 @@ class RootEnv:
 
         for event in self.events:
             if event.type == pg.QUIT or ((event.type == pg.KEYDOWN and event.key == self.__quit_on_key_pressed__ and self.selected_util == None) if self.__quit_on_key_pressed__ != None else False):
+                pg.quit()
                 self.quit = True

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

@@ -125,7 +125,7 @@ class Point(Object):
 class MathFunction(Function):
     def __init__(self,
                  id:int|str,
-                 function:Callable[[int|float, int|float], int|float],
+                 function:Callable[[np.ndarray, np.ndarray], np.ndarray],
                  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:

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

@@ -2,6 +2,7 @@ from __future__ import annotations
 from typing import Any, Callable, Literal
 import pygame as pg
 from e2D import *
+from e2D.colors import *
 
 import math as _mt
 
@@ -12,7 +13,8 @@ __LITERAL_KEY_MODE_TYPES__ = Literal["pressed", "just_pressed", "just_released"]
 
 __LITERAL_FONTS__ = Literal['arial', 'arialblack', 'bahnschrift', 'calibri', 'cambria', 'cambriamath', 'candara', 'comicsansms', 'consolas', 'constantia', 'corbel', 'couriernew', 'ebrima', 'franklingothicmedium', 'gabriola', 'gadugi', 'georgia', 'impact', 'inkfree', 'javanesetext', 'leelawadeeui', 'leelawadeeuisemilight', 'lucidaconsole', 'lucidasans', 'malgungothic', 'malgungothicsemilight', 'microsofthimalaya', 'microsoftjhenghei', 'microsoftjhengheiui', 'microsoftnewtailue', 'microsoftphagspa', 'microsoftsansserif', 'microsofttaile', 'microsoftyahei', 'microsoftyaheiui', 'microsoftyibaiti', 'mingliuextb', 'pmingliuextb', 'mingliuhkscsextb', 'mongolianbaiti', 'msgothic', 'msuigothic', 'mspgothic', 'mvboli', 'myanmartext', 'nirmalaui', 'nirmalauisemilight', 'palatinolinotype', 'segoemdl2assets', 'segoeprint', 'segoescript', 'segoeui', 'segoeuiblack', 'segoeuiemoji', 'segoeuihistoric', 'segoeuisemibold', 'segoeuisemilight', 'segoeuisymbol', 'simsun', 'nsimsun', 'simsunextb', 'sitkasmall', 'sitkatext', 'sitkasubheading', 'sitkaheading', 'sitkadisplay', 'sitkabanner', 'sylfaen', 'symbol', 'tahoma', 'timesnewroman', 'trebuchetms', 'verdana', 'webdings', 'wingdings', 'yugothic', 'yugothicuisemibold', 'yugothicui', 'yugothicmedium', 'yugothicuiregular', 'yugothicregular', 'yugothicuisemilight', 'holomdl2assets', 'bizudgothic', 'bizudpgothictruetype', 'bizudminchomedium', 'bizudpminchomediumtruetype', 'meiryo', 'meiryoui', 'msmincho', 'mspmincho', 'uddigikyokashonb', 'uddigikyokashonpb', 'uddigikyokashonkb', 'uddigikyokashonr', 'uddigikyokashonpr', 'uddigikyokashonkr', 'yumincho', 'lcd', 'glassgauge', 'maiandragd', 'maiandragddemi', 'newsgothic', 'quartz', 'kievitoffcpro', 'agencyfbgrassetto', 'agencyfb', 'algerian', 'bookantiquagrassetto', 'bookantiquagrassettocorsivo', 'bookantiquacorsivo', 'arialcorsivo', 'arialrounded', 'baskervilleoldface', 'bauhaus93', 'bell', 'bellgrassetto', 'bellcorsivo', 'bernardcondensed', 'bookantiqua', 'bodonigrassetto', 'bodonigrassettocorsivo', 'bodoniblackcorsivo', 'bodoniblack', 'bodonicondensedgrassetto', 'bodonicondensedgrassettocorsivo', 'bodonicondensedcorsivo', 'bodonicondensed', 'bodonicorsivo', 'bodonipostercompressed', 'bodoni', 'bookmanoldstyle', 'bookmanoldstylegrassetto', 'bookmanoldstylegrassettocorsivo', 'bookmanoldstylecorsivo', 'bradleyhanditc', 'britannic', 'berlinsansfbgrassetto', 'berlinsansfbdemigrassetto', 'berlinsansfb', 'broadway', 'brushscriptcorsivo', 'bookshelfsymbol7', 'californianfbgrassetto', 'californianfbcorsivo', 'californianfb', 'calisto', 'calistograssetto', 'calistograssettocorsivo', 'calistocorsivo', 'castellar', 'centuryschoolbook', 'centaur', 'century', 'chiller', 'colonna', 'cooperblack', 'copperplategothic', 'curlz', 'dubai', 'dubaimedium', 'dubairegular', 'elephant', 'elephantcorsivo', 'engravers', 'erasitc', 'erasdemiitc', 'erasmediumitc', 'felixtitling', 'forte', 'franklingothicbook', 'franklingothicbookcorsivo', 'franklingothicdemi', 'franklingothicdemicond', 'franklingothicdemicorsivo', 'franklingothicheavy', 'franklingothicheavycorsivo', 'franklingothicmediumcond', 'freestylescript', 'frenchscript', 'footlight', 'garamond', 'garamondgrassetto', 'garamondcorsivo', 'gigi', 'gillsansgrassettocorsivo', 'gillsansgrassetto', 'gillsanscondensed', 'gillsanscorsivo', 'gillsansultracondensed', 'gillsansultra', 'gillsans', 'gloucesterextracondensed', 'gillsansextcondensed', 'centurygothic', 'centurygothicgrassetto', 'centurygothicgrassettocorsivo', 'centurygothiccorsivo', 'goudyoldstyle', 'goudyoldstylegrassetto', 'goudyoldstylecorsivo', 'goudystout', 'harlowsolid', 'harrington', 'haettenschweiler', 'hightowertext', 'hightowertextcorsivo', 'imprintshadow', 'informalroman', 'blackadderitc', 'kristenitc', 'jokerman', 'juiceitc', 'kunstlerscript', 'widelatin', 'lucidabright', 'lucidacalligraphy', 'leelawadee', 'leelawadeegrassetto', 'lucidafax', 'lucidafaxdemigrassetto', 'lucidafaxdemigrassettocorsivo', 'lucidafaxcorsivo', 'lucidahandwritingcorsivo', 'lucidasansdemigrassetto', 'lucidasansdemigrassettocorsivo', 'lucidasanscorsivo', 'lucidasanstypewriter', 'lucidasanstypewritergrassetto', 'lucidasanstypewritergrassettooblique', 'lucidasanstypewriteroblique', 'magnetograssetto', 'maturascriptcapitals', 'mistral', 'modernno20', 'microsoftuighurgrassetto', 'microsoftuighur', 'monotypecorsiva', 'extra', 'niagaraengraved', 'niagarasolid', 'ocraextended', 'oldenglishtext', 'onyx', 'msoutlook', 'palacescript', 'papyrus', 'parchment', 'perpetuagrassettocorsivo', 'perpetuagrassetto', 'perpetuacorsivo', 'perpetuatitlinggrassetto', 'perpetuatitlingchiarissimo', 'perpetua', 'playbill', 'poorrichard', 'pristina', 'rage', 'ravie', 'msreferencesansserif', 'msreferencespecialty', 'rockwellcondensedgrassetto', 'rockwellcondensed', 'rockwell', 'rockwellgrassetto', 'rockwellgrassettocorsivo', 'rockwellextra', 'rockwellcorsivo', 'centuryschoolbookgrassetto', 'centuryschoolbookgrassettocorsivo', 'centuryschoolbookcorsivo', 'script', 'showcardgothic', 'snapitc', 'stencil', 'twcengrassettocorsivo', 'twcengrassetto', 'twcencondensedgrassetto', 'twcencondensedextra', 'twcencondensed', 'twcencorsivo', 'twcen', 'tempussansitc', 'vinerhanditc', 'vivaldicorsivo', 'vladimirscript', 'wingdings2', 'wingdings3', 'cascadiacoderegular', 'cascadiamonoregular', 'edwardianscriptitcnormale', 'stoneharbourregular', 'mregular', 'xirodregular', 'minecraft']
 
-NEW_FONT :Callable[[int, __LITERAL_FONTS__, bool, bool], pg.font.Font]= lambda size, name="arial", bold=False, italic=False: pg.font.SysFont(name, size, bold, italic)
+def NEW_FONT(size, name:__LITERAL_FONTS__="arial", bold:bool=False, italic:bool=False) -> pg.font.Font:
+    return pg.font.SysFont(name, size, bold, italic)
 FONT_ARIAL_16 = NEW_FONT(16)
 FONT_ARIAL_32 = NEW_FONT(32)
 FONT_ARIAL_64 = NEW_FONT(64)
@@ -74,7 +76,7 @@ class Mouse:
 
 class Keyboard:
     def __init__(self) -> None:
-        self.__pressed__ :list= pg.key.get_pressed()
+        self.__pressed__ :pg.key.ScancodeWrapper= pg.key.get_pressed()
         self.update()
     
     def update(self) -> None:
@@ -91,7 +93,6 @@ class Keyboard:
         else:
             raise Exception(f"Unknown mode type: {mode}")
 
-
 class Util:
     def __init__(self) -> None:
         self.rootEnv = None
@@ -108,9 +109,9 @@ class InputCell(Util):
                 position : Vector2D,
                 size : Vector2D,
                 prefix : str|None = None,
-                text_color : tuple[int,int,int]|list[int] = (255,255,255),
-                bg_color : None|tuple[int,int,int]|list[int] = None,
-                border_color : None|tuple[int,int,int]|list[int] = (255,255,255),
+                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(),
@@ -148,13 +149,13 @@ class InputCell(Util):
     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)
+            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)
 
@@ -182,7 +183,7 @@ 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

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: e2D
-Version: 1.4.14
+Version: 1.4.16
 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.14 → e2d-1.4.16}/e2D.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ pyproject.toml
 setup.cfg
 e2D/__init__.py
 e2D/__init__.pyi
+e2D/colors.py
 e2D/envs.py
 e2D/plots.py
 e2D/utils.py

{e2d-1.4.14 → e2d-1.4.16}/setup.cfg

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